From af30ef06f825a79ba22439e659930629b50cbd32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 29 Mar 2022 18:31:32 +0900 Subject: [PATCH 1/5] Add tests --- .../chunks/8a28b14e.d8fbda268ed281a1/input.js | 21412 ++++++++++++++++ .../chunks/981.ed660b563826161d/input.js | 6573 +++++ .../pages/_app-6982cbb7db4140a2/input.js | 226 + .../pages/_error-04f03cfa2a163874/input.js | 25 + .../pages/index-665b680df96552be/input.js | 588 + 5 files changed, 28824 insertions(+) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js new file mode 100644 index 000000000000..5dedce7296e3 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js @@ -0,0 +1,21412 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[281],{ + +/***/ 3239: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/* module decorator */ module = __webpack_require__.nmd(module); +/* ***** BEGIN LICENSE BLOCK ***** + * Distributed under the BSD license: + * + * Copyright (c) 2010, Ajax.org B.V. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * * Neither the name of Ajax.org B.V. nor the + * names of its contributors may be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL AJAX.ORG B.V. BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * ***** END LICENSE BLOCK ***** */ + +/** + * Define a module along with a payload + * @param module a name for the payload + * @param payload a function to call with (require, exports, module) params + */ + +(function() { + +var ACE_NAMESPACE = "ace"; + +var global = (function() { return this; })(); +if (!global && typeof window != "undefined") global = window; // strict mode + + +if (!ACE_NAMESPACE && typeof requirejs !== "undefined") + return; + + +var define = function(module, deps, payload) { + if (typeof module !== "string") { + if (define.original) + define.original.apply(this, arguments); + else { + console.error("dropping module because define wasn\'t a string."); + console.trace(); + } + return; + } + if (arguments.length == 2) + payload = deps; + if (!define.modules[module]) { + define.payloads[module] = payload; + define.modules[module] = null; + } +}; + +define.modules = {}; +define.payloads = {}; + +/** + * Get at functionality define()ed using the function above + */ +var _require = function(parentId, module, callback) { + if (typeof module === "string") { + var payload = lookup(parentId, module); + if (payload != undefined) { + callback && callback(); + return payload; + } + } else if (Object.prototype.toString.call(module) === "[object Array]") { + var params = []; + for (var i = 0, l = module.length; i < l; ++i) { + var dep = lookup(parentId, module[i]); + if (dep == undefined && require.original) + return; + params.push(dep); + } + return callback && callback.apply(null, params) || true; + } +}; + +var require = function(module, callback) { + var packagedModule = _require("", module, callback); + if (packagedModule == undefined && require.original) + return require.original.apply(this, arguments); + return packagedModule; +}; + +var normalizeModule = function(parentId, moduleName) { + // normalize plugin requires + if (moduleName.indexOf("!") !== -1) { + var chunks = moduleName.split("!"); + return normalizeModule(parentId, chunks[0]) + "!" + normalizeModule(parentId, chunks[1]); + } + // normalize relative requires + if (moduleName.charAt(0) == ".") { + var base = parentId.split("/").slice(0, -1).join("/"); + moduleName = base + "/" + moduleName; + + while(moduleName.indexOf(".") !== -1 && previous != moduleName) { + var previous = moduleName; + moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, ""); + } + } + return moduleName; +}; + +/** + * Internal function to lookup moduleNames and resolve them by calling the + * definition function if needed. + */ +var lookup = function(parentId, moduleName) { + moduleName = normalizeModule(parentId, moduleName); + + var module = define.modules[moduleName]; + if (!module) { + module = define.payloads[moduleName]; + if (typeof module === 'function') { + var exports = {}; + var mod = { + id: moduleName, + uri: '', + exports: exports, + packaged: true + }; + + var req = function(module, callback) { + return _require(moduleName, module, callback); + }; + + var returnValue = module(req, exports, mod); + exports = returnValue || mod.exports; + define.modules[moduleName] = exports; + delete define.payloads[moduleName]; + } + module = define.modules[moduleName] = exports || module; + } + return module; +}; + +function exportAce(ns) { + var root = global; + if (ns) { + if (!global[ns]) + global[ns] = {}; + root = global[ns]; + } + + if (!root.define || !root.define.packaged) { + define.original = root.define; + root.define = define; + root.define.packaged = true; + } + + if (!root.require || !root.require.packaged) { + require.original = root.require; + root.require = require; + root.require.packaged = true; + } +} + +exportAce(ACE_NAMESPACE); + +})(); + +ace.define("ace/lib/fixoldbrowsers",["require","exports","module"], function(require, exports, module) { +"use strict"; +if (typeof Element != "undefined" && !Element.prototype.remove) { + Object.defineProperty(Element.prototype, "remove", { + enumerable: false, + writable: true, + configurable: true, + value: function() { this.parentNode && this.parentNode.removeChild(this); } + }); +} + + +}); + +ace.define("ace/lib/useragent",["require","exports","module"], function(require, exports, module) { +"use strict"; +exports.OS = { + LINUX: "LINUX", + MAC: "MAC", + WINDOWS: "WINDOWS" +}; +exports.getOS = function() { + if (exports.isMac) { + return exports.OS.MAC; + } else if (exports.isLinux) { + return exports.OS.LINUX; + } else { + return exports.OS.WINDOWS; + } +}; +var _navigator = typeof navigator == "object" ? navigator : {}; + +var os = (/mac|win|linux/i.exec(_navigator.platform) || ["other"])[0].toLowerCase(); +var ua = _navigator.userAgent || ""; +var appName = _navigator.appName || ""; +exports.isWin = (os == "win"); +exports.isMac = (os == "mac"); +exports.isLinux = (os == "linux"); +exports.isIE = + (appName == "Microsoft Internet Explorer" || appName.indexOf("MSAppHost") >= 0) + ? parseFloat((ua.match(/(?:MSIE |Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/)||[])[1]) + : parseFloat((ua.match(/(?:Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/)||[])[1]); // for ie + +exports.isOldIE = exports.isIE && exports.isIE < 9; +exports.isGecko = exports.isMozilla = ua.match(/ Gecko\/\d+/); +exports.isOpera = typeof opera == "object" && Object.prototype.toString.call(window.opera) == "[object Opera]"; +exports.isWebKit = parseFloat(ua.split("WebKit/")[1]) || undefined; + +exports.isChrome = parseFloat(ua.split(" Chrome/")[1]) || undefined; + +exports.isEdge = parseFloat(ua.split(" Edge/")[1]) || undefined; + +exports.isAIR = ua.indexOf("AdobeAIR") >= 0; + +exports.isAndroid = ua.indexOf("Android") >= 0; + +exports.isChromeOS = ua.indexOf(" CrOS ") >= 0; + +exports.isIOS = /iPad|iPhone|iPod/.test(ua) && !window.MSStream; + +if (exports.isIOS) exports.isMac = true; + +exports.isMobile = exports.isIOS || exports.isAndroid; + +}); + +ace.define("ace/lib/dom",["require","exports","module","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var useragent = require("./useragent"); +var XHTML_NS = "http://www.w3.org/1999/xhtml"; + +exports.buildDom = function buildDom(arr, parent, refs) { + if (typeof arr == "string" && arr) { + var txt = document.createTextNode(arr); + if (parent) + parent.appendChild(txt); + return txt; + } + + if (!Array.isArray(arr)) { + if (arr && arr.appendChild && parent) + parent.appendChild(arr); + return arr; + } + if (typeof arr[0] != "string" || !arr[0]) { + var els = []; + for (var i = 0; i < arr.length; i++) { + var ch = buildDom(arr[i], parent, refs); + ch && els.push(ch); + } + return els; + } + + var el = document.createElement(arr[0]); + var options = arr[1]; + var childIndex = 1; + if (options && typeof options == "object" && !Array.isArray(options)) + childIndex = 2; + for (var i = childIndex; i < arr.length; i++) + buildDom(arr[i], el, refs); + if (childIndex == 2) { + Object.keys(options).forEach(function(n) { + var val = options[n]; + if (n === "class") { + el.className = Array.isArray(val) ? val.join(" ") : val; + } else if (typeof val == "function" || n == "value" || n[0] == "$") { + el[n] = val; + } else if (n === "ref") { + if (refs) refs[val] = el; + } else if (n === "style") { + if (typeof val == "string") el.style.cssText = val; + } else if (val != null) { + el.setAttribute(n, val); + } + }); + } + if (parent) + parent.appendChild(el); + return el; +}; + +exports.getDocumentHead = function(doc) { + if (!doc) + doc = document; + return doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement; +}; + +exports.createElement = function(tag, ns) { + return document.createElementNS ? + document.createElementNS(ns || XHTML_NS, tag) : + document.createElement(tag); +}; + +exports.removeChildren = function(element) { + element.innerHTML = ""; +}; + +exports.createTextNode = function(textContent, element) { + var doc = element ? element.ownerDocument : document; + return doc.createTextNode(textContent); +}; + +exports.createFragment = function(element) { + var doc = element ? element.ownerDocument : document; + return doc.createDocumentFragment(); +}; + +exports.hasCssClass = function(el, name) { + var classes = (el.className + "").split(/\s+/g); + return classes.indexOf(name) !== -1; +}; +exports.addCssClass = function(el, name) { + if (!exports.hasCssClass(el, name)) { + el.className += " " + name; + } +}; +exports.removeCssClass = function(el, name) { + var classes = el.className.split(/\s+/g); + while (true) { + var index = classes.indexOf(name); + if (index == -1) { + break; + } + classes.splice(index, 1); + } + el.className = classes.join(" "); +}; + +exports.toggleCssClass = function(el, name) { + var classes = el.className.split(/\s+/g), add = true; + while (true) { + var index = classes.indexOf(name); + if (index == -1) { + break; + } + add = false; + classes.splice(index, 1); + } + if (add) + classes.push(name); + + el.className = classes.join(" "); + return add; +}; +exports.setCssClass = function(node, className, include) { + if (include) { + exports.addCssClass(node, className); + } else { + exports.removeCssClass(node, className); + } +}; + +exports.hasCssString = function(id, doc) { + var index = 0, sheets; + doc = doc || document; + if ((sheets = doc.querySelectorAll("style"))) { + while (index < sheets.length) + if (sheets[index++].id === id) + return true; + } +}; + +var strictCSP; +var cssCache = []; +exports.useStrictCSP = function(value) { + strictCSP = value; + if (value == false) insertPendingStyles(); + else if (!cssCache) cssCache = []; +}; + +function insertPendingStyles() { + var cache = cssCache; + cssCache = null; + cache && cache.forEach(function(item) { + importCssString(item[0], item[1]); + }); +} + +function importCssString(cssText, id, target) { + if (typeof document == "undefined") + return; + if (cssCache) { + if (target) { + insertPendingStyles(); + } else if (target === false) { + return cssCache.push([cssText, id]); + } + } + if (strictCSP) return; + + var container = target; + if (!target || !target.getRootNode) { + container = document; + } else { + container = target.getRootNode(); + if (!container || container == target) + container = document; + } + + var doc = container.ownerDocument || container; + if (id && exports.hasCssString(id, container)) + return null; + + if (id) + cssText += "\n/*# sourceURL=ace/css/" + id + " */"; + + var style = exports.createElement("style"); + style.appendChild(doc.createTextNode(cssText)); + if (id) + style.id = id; + + if (container == doc) + container = exports.getDocumentHead(doc); + container.insertBefore(style, container.firstChild); +} +exports.importCssString = importCssString; + +exports.importCssStylsheet = function(uri, doc) { + exports.buildDom(["link", {rel: "stylesheet", href: uri}], exports.getDocumentHead(doc)); +}; +exports.scrollbarWidth = function(document) { + var inner = exports.createElement("ace_inner"); + inner.style.width = "100%"; + inner.style.minWidth = "0px"; + inner.style.height = "200px"; + inner.style.display = "block"; + + var outer = exports.createElement("ace_outer"); + var style = outer.style; + + style.position = "absolute"; + style.left = "-10000px"; + style.overflow = "hidden"; + style.width = "200px"; + style.minWidth = "0px"; + style.height = "150px"; + style.display = "block"; + + outer.appendChild(inner); + + var body = document.documentElement; + body.appendChild(outer); + + var noScrollbar = inner.offsetWidth; + + style.overflow = "scroll"; + var withScrollbar = inner.offsetWidth; + + if (noScrollbar == withScrollbar) { + withScrollbar = outer.clientWidth; + } + + body.removeChild(outer); + + return noScrollbar-withScrollbar; +}; + +exports.computedStyle = function(element, style) { + return window.getComputedStyle(element, "") || {}; +}; + +exports.setStyle = function(styles, property, value) { + if (styles[property] !== value) { + styles[property] = value; + } +}; + +exports.HAS_CSS_ANIMATION = false; +exports.HAS_CSS_TRANSFORMS = false; +exports.HI_DPI = useragent.isWin + ? typeof window !== "undefined" && window.devicePixelRatio >= 1.5 + : true; + +if (useragent.isChromeOS) exports.HI_DPI = false; + +if (typeof document !== "undefined") { + var div = document.createElement("div"); + if (exports.HI_DPI && div.style.transform !== undefined) + exports.HAS_CSS_TRANSFORMS = true; + if (!useragent.isEdge && typeof div.style.animationName !== "undefined") + exports.HAS_CSS_ANIMATION = true; + div = null; +} + +if (exports.HAS_CSS_TRANSFORMS) { + exports.translate = function(element, tx, ty) { + element.style.transform = "translate(" + Math.round(tx) + "px, " + Math.round(ty) +"px)"; + }; +} else { + exports.translate = function(element, tx, ty) { + element.style.top = Math.round(ty) + "px"; + element.style.left = Math.round(tx) + "px"; + }; +} + +}); + +ace.define("ace/lib/oop",["require","exports","module"], function(require, exports, module) { +"use strict"; + +exports.inherits = function(ctor, superCtor) { + ctor.super_ = superCtor; + ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: false, + writable: true, + configurable: true + } + }); +}; + +exports.mixin = function(obj, mixin) { + for (var key in mixin) { + obj[key] = mixin[key]; + } + return obj; +}; + +exports.implement = function(proto, mixin) { + exports.mixin(proto, mixin); +}; + +}); + +ace.define("ace/lib/keys",["require","exports","module","ace/lib/oop"], function(require, exports, module) { +"use strict"; + +var oop = require("./oop"); +var Keys = (function() { + var ret = { + MODIFIER_KEYS: { + 16: 'Shift', 17: 'Ctrl', 18: 'Alt', 224: 'Meta', + 91: 'MetaLeft', 92: 'MetaRight', 93: 'ContextMenu' + }, + + KEY_MODS: { + "ctrl": 1, "alt": 2, "option" : 2, "shift": 4, + "super": 8, "meta": 8, "command": 8, "cmd": 8, + "control": 1 + }, + + FUNCTION_KEYS : { + 8 : "Backspace", + 9 : "Tab", + 13 : "Return", + 19 : "Pause", + 27 : "Esc", + 32 : "Space", + 33 : "PageUp", + 34 : "PageDown", + 35 : "End", + 36 : "Home", + 37 : "Left", + 38 : "Up", + 39 : "Right", + 40 : "Down", + 44 : "Print", + 45 : "Insert", + 46 : "Delete", + 96 : "Numpad0", + 97 : "Numpad1", + 98 : "Numpad2", + 99 : "Numpad3", + 100: "Numpad4", + 101: "Numpad5", + 102: "Numpad6", + 103: "Numpad7", + 104: "Numpad8", + 105: "Numpad9", + '-13': "NumpadEnter", + 112: "F1", + 113: "F2", + 114: "F3", + 115: "F4", + 116: "F5", + 117: "F6", + 118: "F7", + 119: "F8", + 120: "F9", + 121: "F10", + 122: "F11", + 123: "F12", + 144: "Numlock", + 145: "Scrolllock" + }, + + PRINTABLE_KEYS: { + 32: ' ', 48: '0', 49: '1', 50: '2', 51: '3', 52: '4', 53: '5', + 54: '6', 55: '7', 56: '8', 57: '9', 59: ';', 61: '=', 65: 'a', + 66: 'b', 67: 'c', 68: 'd', 69: 'e', 70: 'f', 71: 'g', 72: 'h', + 73: 'i', 74: 'j', 75: 'k', 76: 'l', 77: 'm', 78: 'n', 79: 'o', + 80: 'p', 81: 'q', 82: 'r', 83: 's', 84: 't', 85: 'u', 86: 'v', + 87: 'w', 88: 'x', 89: 'y', 90: 'z', 107: '+', 109: '-', 110: '.', + 186: ';', 187: '=', 188: ',', 189: '-', 190: '.', 191: '/', 192: '`', + 219: '[', 220: '\\',221: ']', 222: "'", 111: '/', 106: '*' + } + }; + var name, i; + for (i in ret.FUNCTION_KEYS) { + name = ret.FUNCTION_KEYS[i].toLowerCase(); + ret[name] = parseInt(i, 10); + } + for (i in ret.PRINTABLE_KEYS) { + name = ret.PRINTABLE_KEYS[i].toLowerCase(); + ret[name] = parseInt(i, 10); + } + oop.mixin(ret, ret.MODIFIER_KEYS); + oop.mixin(ret, ret.PRINTABLE_KEYS); + oop.mixin(ret, ret.FUNCTION_KEYS); + ret.enter = ret["return"]; + ret.escape = ret.esc; + ret.del = ret["delete"]; + ret[173] = '-'; + + (function() { + var mods = ["cmd", "ctrl", "alt", "shift"]; + for (var i = Math.pow(2, mods.length); i--;) { + ret.KEY_MODS[i] = mods.filter(function(x) { + return i & ret.KEY_MODS[x]; + }).join("-") + "-"; + } + })(); + + ret.KEY_MODS[0] = ""; + ret.KEY_MODS[-1] = "input-"; + + return ret; +})(); +oop.mixin(exports, Keys); + +exports.keyCodeToString = function(keyCode) { + var keyString = Keys[keyCode]; + if (typeof keyString != "string") + keyString = String.fromCharCode(keyCode); + return keyString.toLowerCase(); +}; + +}); + +ace.define("ace/lib/event",["require","exports","module","ace/lib/keys","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var keys = require("./keys"); +var useragent = require("./useragent"); + +var pressedKeys = null; +var ts = 0; + +var activeListenerOptions; +function detectListenerOptionsSupport() { + activeListenerOptions = false; + try { + document.createComment("").addEventListener("test", function() {}, { + get passive() { + activeListenerOptions = {passive: false}; + } + }); + } catch(e) {} +} + +function getListenerOptions() { + if (activeListenerOptions == undefined) + detectListenerOptionsSupport(); + return activeListenerOptions; +} + +function EventListener(elem, type, callback) { + this.elem = elem; + this.type = type; + this.callback = callback; +} +EventListener.prototype.destroy = function() { + removeListener(this.elem, this.type, this.callback); + this.elem = this.type = this.callback = undefined; +}; + +var addListener = exports.addListener = function(elem, type, callback, destroyer) { + elem.addEventListener(type, callback, getListenerOptions()); + if (destroyer) + destroyer.$toDestroy.push(new EventListener(elem, type, callback)); +}; + +var removeListener = exports.removeListener = function(elem, type, callback) { + elem.removeEventListener(type, callback, getListenerOptions()); +}; +exports.stopEvent = function(e) { + exports.stopPropagation(e); + exports.preventDefault(e); + return false; +}; + +exports.stopPropagation = function(e) { + if (e.stopPropagation) + e.stopPropagation(); +}; + +exports.preventDefault = function(e) { + if (e.preventDefault) + e.preventDefault(); +}; +exports.getButton = function(e) { + if (e.type == "dblclick") + return 0; + if (e.type == "contextmenu" || (useragent.isMac && (e.ctrlKey && !e.altKey && !e.shiftKey))) + return 2; + return e.button; +}; + +exports.capture = function(el, eventHandler, releaseCaptureHandler) { + var ownerDocument = el && el.ownerDocument || document; + function onMouseUp(e) { + eventHandler && eventHandler(e); + releaseCaptureHandler && releaseCaptureHandler(e); + + removeListener(ownerDocument, "mousemove", eventHandler); + removeListener(ownerDocument, "mouseup", onMouseUp); + removeListener(ownerDocument, "dragstart", onMouseUp); + } + + addListener(ownerDocument, "mousemove", eventHandler); + addListener(ownerDocument, "mouseup", onMouseUp); + addListener(ownerDocument, "dragstart", onMouseUp); + + return onMouseUp; +}; + +exports.addMouseWheelListener = function(el, callback, destroyer) { + if ("onmousewheel" in el) { + addListener(el, "mousewheel", function(e) { + var factor = 8; + if (e.wheelDeltaX !== undefined) { + e.wheelX = -e.wheelDeltaX / factor; + e.wheelY = -e.wheelDeltaY / factor; + } else { + e.wheelX = 0; + e.wheelY = -e.wheelDelta / factor; + } + callback(e); + }, destroyer); + } else if ("onwheel" in el) { + addListener(el, "wheel", function(e) { + var factor = 0.35; + switch (e.deltaMode) { + case e.DOM_DELTA_PIXEL: + e.wheelX = e.deltaX * factor || 0; + e.wheelY = e.deltaY * factor || 0; + break; + case e.DOM_DELTA_LINE: + case e.DOM_DELTA_PAGE: + e.wheelX = (e.deltaX || 0) * 5; + e.wheelY = (e.deltaY || 0) * 5; + break; + } + + callback(e); + }, destroyer); + } else { + addListener(el, "DOMMouseScroll", function(e) { + if (e.axis && e.axis == e.HORIZONTAL_AXIS) { + e.wheelX = (e.detail || 0) * 5; + e.wheelY = 0; + } else { + e.wheelX = 0; + e.wheelY = (e.detail || 0) * 5; + } + callback(e); + }, destroyer); + } +}; + +exports.addMultiMouseDownListener = function(elements, timeouts, eventHandler, callbackName, destroyer) { + var clicks = 0; + var startX, startY, timer; + var eventNames = { + 2: "dblclick", + 3: "tripleclick", + 4: "quadclick" + }; + + function onMousedown(e) { + if (exports.getButton(e) !== 0) { + clicks = 0; + } else if (e.detail > 1) { + clicks++; + if (clicks > 4) + clicks = 1; + } else { + clicks = 1; + } + if (useragent.isIE) { + var isNewClick = Math.abs(e.clientX - startX) > 5 || Math.abs(e.clientY - startY) > 5; + if (!timer || isNewClick) + clicks = 1; + if (timer) + clearTimeout(timer); + timer = setTimeout(function() {timer = null;}, timeouts[clicks - 1] || 600); + + if (clicks == 1) { + startX = e.clientX; + startY = e.clientY; + } + } + + e._clicks = clicks; + + eventHandler[callbackName]("mousedown", e); + + if (clicks > 4) + clicks = 0; + else if (clicks > 1) + return eventHandler[callbackName](eventNames[clicks], e); + } + if (!Array.isArray(elements)) + elements = [elements]; + elements.forEach(function(el) { + addListener(el, "mousedown", onMousedown, destroyer); + }); +}; + +var getModifierHash = function(e) { + return 0 | (e.ctrlKey ? 1 : 0) | (e.altKey ? 2 : 0) | (e.shiftKey ? 4 : 0) | (e.metaKey ? 8 : 0); +}; + +exports.getModifierString = function(e) { + return keys.KEY_MODS[getModifierHash(e)]; +}; + +function normalizeCommandKeys(callback, e, keyCode) { + var hashId = getModifierHash(e); + + if (!useragent.isMac && pressedKeys) { + if (e.getModifierState && (e.getModifierState("OS") || e.getModifierState("Win"))) + hashId |= 8; + if (pressedKeys.altGr) { + if ((3 & hashId) != 3) + pressedKeys.altGr = 0; + else + return; + } + if (keyCode === 18 || keyCode === 17) { + var location = "location" in e ? e.location : e.keyLocation; + if (keyCode === 17 && location === 1) { + if (pressedKeys[keyCode] == 1) + ts = e.timeStamp; + } else if (keyCode === 18 && hashId === 3 && location === 2) { + var dt = e.timeStamp - ts; + if (dt < 50) + pressedKeys.altGr = true; + } + } + } + + if (keyCode in keys.MODIFIER_KEYS) { + keyCode = -1; + } + + if (!hashId && keyCode === 13) { + var location = "location" in e ? e.location : e.keyLocation; + if (location === 3) { + callback(e, hashId, -keyCode); + if (e.defaultPrevented) + return; + } + } + + if (useragent.isChromeOS && hashId & 8) { + callback(e, hashId, keyCode); + if (e.defaultPrevented) + return; + else + hashId &= ~8; + } + if (!hashId && !(keyCode in keys.FUNCTION_KEYS) && !(keyCode in keys.PRINTABLE_KEYS)) { + return false; + } + + return callback(e, hashId, keyCode); +} + + +exports.addCommandKeyListener = function(el, callback, destroyer) { + if (useragent.isOldGecko || (useragent.isOpera && !("KeyboardEvent" in window))) { + var lastKeyDownKeyCode = null; + addListener(el, "keydown", function(e) { + lastKeyDownKeyCode = e.keyCode; + }, destroyer); + addListener(el, "keypress", function(e) { + return normalizeCommandKeys(callback, e, lastKeyDownKeyCode); + }, destroyer); + } else { + var lastDefaultPrevented = null; + + addListener(el, "keydown", function(e) { + pressedKeys[e.keyCode] = (pressedKeys[e.keyCode] || 0) + 1; + var result = normalizeCommandKeys(callback, e, e.keyCode); + lastDefaultPrevented = e.defaultPrevented; + return result; + }, destroyer); + + addListener(el, "keypress", function(e) { + if (lastDefaultPrevented && (e.ctrlKey || e.altKey || e.shiftKey || e.metaKey)) { + exports.stopEvent(e); + lastDefaultPrevented = null; + } + }, destroyer); + + addListener(el, "keyup", function(e) { + pressedKeys[e.keyCode] = null; + }, destroyer); + + if (!pressedKeys) { + resetPressedKeys(); + addListener(window, "focus", resetPressedKeys); + } + } +}; +function resetPressedKeys() { + pressedKeys = Object.create(null); +} + +if (typeof window == "object" && window.postMessage && !useragent.isOldIE) { + var postMessageId = 1; + exports.nextTick = function(callback, win) { + win = win || window; + var messageName = "zero-timeout-message-" + (postMessageId++); + + var listener = function(e) { + if (e.data == messageName) { + exports.stopPropagation(e); + removeListener(win, "message", listener); + callback(); + } + }; + + addListener(win, "message", listener); + win.postMessage(messageName, "*"); + }; +} + +exports.$idleBlocked = false; +exports.onIdle = function(cb, timeout) { + return setTimeout(function handler() { + if (!exports.$idleBlocked) { + cb(); + } else { + setTimeout(handler, 100); + } + }, timeout); +}; + +exports.$idleBlockId = null; +exports.blockIdle = function(delay) { + if (exports.$idleBlockId) + clearTimeout(exports.$idleBlockId); + + exports.$idleBlocked = true; + exports.$idleBlockId = setTimeout(function() { + exports.$idleBlocked = false; + }, delay || 100); +}; + +exports.nextFrame = typeof window == "object" && (window.requestAnimationFrame + || window.mozRequestAnimationFrame + || window.webkitRequestAnimationFrame + || window.msRequestAnimationFrame + || window.oRequestAnimationFrame); + +if (exports.nextFrame) + exports.nextFrame = exports.nextFrame.bind(window); +else + exports.nextFrame = function(callback) { + setTimeout(callback, 17); + }; +}); + +ace.define("ace/range",["require","exports","module"], function(require, exports, module) { +"use strict"; +var comparePoints = function(p1, p2) { + return p1.row - p2.row || p1.column - p2.column; +}; +var Range = function(startRow, startColumn, endRow, endColumn) { + this.start = { + row: startRow, + column: startColumn + }; + + this.end = { + row: endRow, + column: endColumn + }; +}; + +(function() { + this.isEqual = function(range) { + return this.start.row === range.start.row && + this.end.row === range.end.row && + this.start.column === range.start.column && + this.end.column === range.end.column; + }; + this.toString = function() { + return ("Range: [" + this.start.row + "/" + this.start.column + + "] -> [" + this.end.row + "/" + this.end.column + "]"); + }; + + this.contains = function(row, column) { + return this.compare(row, column) == 0; + }; + this.compareRange = function(range) { + var cmp, + end = range.end, + start = range.start; + + cmp = this.compare(end.row, end.column); + if (cmp == 1) { + cmp = this.compare(start.row, start.column); + if (cmp == 1) { + return 2; + } else if (cmp == 0) { + return 1; + } else { + return 0; + } + } else if (cmp == -1) { + return -2; + } else { + cmp = this.compare(start.row, start.column); + if (cmp == -1) { + return -1; + } else if (cmp == 1) { + return 42; + } else { + return 0; + } + } + }; + this.comparePoint = function(p) { + return this.compare(p.row, p.column); + }; + this.containsRange = function(range) { + return this.comparePoint(range.start) == 0 && this.comparePoint(range.end) == 0; + }; + this.intersects = function(range) { + var cmp = this.compareRange(range); + return (cmp == -1 || cmp == 0 || cmp == 1); + }; + this.isEnd = function(row, column) { + return this.end.row == row && this.end.column == column; + }; + this.isStart = function(row, column) { + return this.start.row == row && this.start.column == column; + }; + this.setStart = function(row, column) { + if (typeof row == "object") { + this.start.column = row.column; + this.start.row = row.row; + } else { + this.start.row = row; + this.start.column = column; + } + }; + this.setEnd = function(row, column) { + if (typeof row == "object") { + this.end.column = row.column; + this.end.row = row.row; + } else { + this.end.row = row; + this.end.column = column; + } + }; + this.inside = function(row, column) { + if (this.compare(row, column) == 0) { + if (this.isEnd(row, column) || this.isStart(row, column)) { + return false; + } else { + return true; + } + } + return false; + }; + this.insideStart = function(row, column) { + if (this.compare(row, column) == 0) { + if (this.isEnd(row, column)) { + return false; + } else { + return true; + } + } + return false; + }; + this.insideEnd = function(row, column) { + if (this.compare(row, column) == 0) { + if (this.isStart(row, column)) { + return false; + } else { + return true; + } + } + return false; + }; + this.compare = function(row, column) { + if (!this.isMultiLine()) { + if (row === this.start.row) { + return column < this.start.column ? -1 : (column > this.end.column ? 1 : 0); + } + } + + if (row < this.start.row) + return -1; + + if (row > this.end.row) + return 1; + + if (this.start.row === row) + return column >= this.start.column ? 0 : -1; + + if (this.end.row === row) + return column <= this.end.column ? 0 : 1; + + return 0; + }; + this.compareStart = function(row, column) { + if (this.start.row == row && this.start.column == column) { + return -1; + } else { + return this.compare(row, column); + } + }; + this.compareEnd = function(row, column) { + if (this.end.row == row && this.end.column == column) { + return 1; + } else { + return this.compare(row, column); + } + }; + this.compareInside = function(row, column) { + if (this.end.row == row && this.end.column == column) { + return 1; + } else if (this.start.row == row && this.start.column == column) { + return -1; + } else { + return this.compare(row, column); + } + }; + this.clipRows = function(firstRow, lastRow) { + if (this.end.row > lastRow) + var end = {row: lastRow + 1, column: 0}; + else if (this.end.row < firstRow) + var end = {row: firstRow, column: 0}; + + if (this.start.row > lastRow) + var start = {row: lastRow + 1, column: 0}; + else if (this.start.row < firstRow) + var start = {row: firstRow, column: 0}; + + return Range.fromPoints(start || this.start, end || this.end); + }; + this.extend = function(row, column) { + var cmp = this.compare(row, column); + + if (cmp == 0) + return this; + else if (cmp == -1) + var start = {row: row, column: column}; + else + var end = {row: row, column: column}; + + return Range.fromPoints(start || this.start, end || this.end); + }; + + this.isEmpty = function() { + return (this.start.row === this.end.row && this.start.column === this.end.column); + }; + this.isMultiLine = function() { + return (this.start.row !== this.end.row); + }; + this.clone = function() { + return Range.fromPoints(this.start, this.end); + }; + this.collapseRows = function() { + if (this.end.column == 0) + return new Range(this.start.row, 0, Math.max(this.start.row, this.end.row-1), 0); + else + return new Range(this.start.row, 0, this.end.row, 0); + }; + this.toScreenRange = function(session) { + var screenPosStart = session.documentToScreenPosition(this.start); + var screenPosEnd = session.documentToScreenPosition(this.end); + + return new Range( + screenPosStart.row, screenPosStart.column, + screenPosEnd.row, screenPosEnd.column + ); + }; + this.moveBy = function(row, column) { + this.start.row += row; + this.start.column += column; + this.end.row += row; + this.end.column += column; + }; + +}).call(Range.prototype); +Range.fromPoints = function(start, end) { + return new Range(start.row, start.column, end.row, end.column); +}; +Range.comparePoints = comparePoints; + +Range.comparePoints = function(p1, p2) { + return p1.row - p2.row || p1.column - p2.column; +}; + + +exports.Range = Range; +}); + +ace.define("ace/lib/lang",["require","exports","module"], function(require, exports, module) { +"use strict"; + +exports.last = function(a) { + return a[a.length - 1]; +}; + +exports.stringReverse = function(string) { + return string.split("").reverse().join(""); +}; + +exports.stringRepeat = function (string, count) { + var result = ''; + while (count > 0) { + if (count & 1) + result += string; + + if (count >>= 1) + string += string; + } + return result; +}; + +var trimBeginRegexp = /^\s\s*/; +var trimEndRegexp = /\s\s*$/; + +exports.stringTrimLeft = function (string) { + return string.replace(trimBeginRegexp, ''); +}; + +exports.stringTrimRight = function (string) { + return string.replace(trimEndRegexp, ''); +}; + +exports.copyObject = function(obj) { + var copy = {}; + for (var key in obj) { + copy[key] = obj[key]; + } + return copy; +}; + +exports.copyArray = function(array){ + var copy = []; + for (var i=0, l=array.length; i Date.now() - 50) + return true; + return $cancelT = false; + }, + cancel: function() { + $cancelT = Date.now(); + } +}; + +}); + +ace.define("ace/keyboard/textinput",["require","exports","module","ace/lib/event","ace/lib/useragent","ace/lib/dom","ace/lib/lang","ace/clipboard","ace/lib/keys"], function(require, exports, module) { +"use strict"; + +var event = require("../lib/event"); +var useragent = require("../lib/useragent"); +var dom = require("../lib/dom"); +var lang = require("../lib/lang"); +var clipboard = require("../clipboard"); +var BROKEN_SETDATA = useragent.isChrome < 18; +var USE_IE_MIME_TYPE = useragent.isIE; +var HAS_FOCUS_ARGS = useragent.isChrome > 63; +var MAX_LINE_LENGTH = 400; + +var KEYS = require("../lib/keys"); +var MODS = KEYS.KEY_MODS; +var isIOS = useragent.isIOS; +var valueResetRegex = isIOS ? /\s/ : /\n/; +var isMobile = useragent.isMobile; + +var TextInput = function(parentNode, host) { + var text = dom.createElement("textarea"); + text.className = "ace_text-input"; + + text.setAttribute("wrap", "off"); + text.setAttribute("autocorrect", "off"); + text.setAttribute("autocapitalize", "off"); + text.setAttribute("spellcheck", false); + + text.style.opacity = "0"; + parentNode.insertBefore(text, parentNode.firstChild); + + var copied = false; + var pasted = false; + var inComposition = false; + var sendingText = false; + var tempStyle = ''; + + if (!isMobile) + text.style.fontSize = "1px"; + + var commandMode = false; + var ignoreFocusEvents = false; + + var lastValue = ""; + var lastSelectionStart = 0; + var lastSelectionEnd = 0; + var lastRestoreEnd = 0; + try { var isFocused = document.activeElement === text; } catch(e) {} + + event.addListener(text, "blur", function(e) { + if (ignoreFocusEvents) return; + host.onBlur(e); + isFocused = false; + }, host); + event.addListener(text, "focus", function(e) { + if (ignoreFocusEvents) return; + isFocused = true; + if (useragent.isEdge) { + try { + if (!document.hasFocus()) + return; + } catch(e) {} + } + host.onFocus(e); + if (useragent.isEdge) + setTimeout(resetSelection); + else + resetSelection(); + }, host); + this.$focusScroll = false; + this.focus = function() { + if (tempStyle || HAS_FOCUS_ARGS || this.$focusScroll == "browser") + return text.focus({ preventScroll: true }); + + var top = text.style.top; + text.style.position = "fixed"; + text.style.top = "0px"; + try { + var isTransformed = text.getBoundingClientRect().top != 0; + } catch(e) { + return; + } + var ancestors = []; + if (isTransformed) { + var t = text.parentElement; + while (t && t.nodeType == 1) { + ancestors.push(t); + t.setAttribute("ace_nocontext", true); + if (!t.parentElement && t.getRootNode) + t = t.getRootNode().host; + else + t = t.parentElement; + } + } + text.focus({ preventScroll: true }); + if (isTransformed) { + ancestors.forEach(function(p) { + p.removeAttribute("ace_nocontext"); + }); + } + setTimeout(function() { + text.style.position = ""; + if (text.style.top == "0px") + text.style.top = top; + }, 0); + }; + this.blur = function() { + text.blur(); + }; + this.isFocused = function() { + return isFocused; + }; + + host.on("beforeEndOperation", function() { + var curOp = host.curOp; + var commandName = curOp && curOp.command && curOp.command.name; + if (commandName == "insertstring") + return; + var isUserAction = commandName && (curOp.docChanged || curOp.selectionChanged); + if (inComposition && isUserAction) { + lastValue = text.value = ""; + onCompositionEnd(); + } + resetSelection(); + }); + + var resetSelection = isIOS + ? function(value) { + if (!isFocused || (copied && !value) || sendingText) return; + if (!value) + value = ""; + var newValue = "\n ab" + value + "cde fg\n"; + if (newValue != text.value) + text.value = lastValue = newValue; + + var selectionStart = 4; + var selectionEnd = 4 + (value.length || (host.selection.isEmpty() ? 0 : 1)); + + if (lastSelectionStart != selectionStart || lastSelectionEnd != selectionEnd) { + text.setSelectionRange(selectionStart, selectionEnd); + } + lastSelectionStart = selectionStart; + lastSelectionEnd = selectionEnd; + } + : function() { + if (inComposition || sendingText) + return; + if (!isFocused && !afterContextMenu) + return; + inComposition = true; + + var selectionStart = 0; + var selectionEnd = 0; + var line = ""; + + if (host.session) { + var selection = host.selection; + var range = selection.getRange(); + var row = selection.cursor.row; + selectionStart = range.start.column; + selectionEnd = range.end.column; + line = host.session.getLine(row); + + if (range.start.row != row) { + var prevLine = host.session.getLine(row - 1); + selectionStart = range.start.row < row - 1 ? 0 : selectionStart; + selectionEnd += prevLine.length + 1; + line = prevLine + "\n" + line; + } + else if (range.end.row != row) { + var nextLine = host.session.getLine(row + 1); + selectionEnd = range.end.row > row + 1 ? nextLine.length : selectionEnd; + selectionEnd += line.length + 1; + line = line + "\n" + nextLine; + } + else if (isMobile && row > 0) { + line = "\n" + line; + selectionEnd += 1; + selectionStart += 1; + } + + if (line.length > MAX_LINE_LENGTH) { + if (selectionStart < MAX_LINE_LENGTH && selectionEnd < MAX_LINE_LENGTH) { + line = line.slice(0, MAX_LINE_LENGTH); + } else { + line = "\n"; + if (selectionStart == selectionEnd) { + selectionStart = selectionEnd = 0; + } + else { + selectionStart = 0; + selectionEnd = 1; + } + } + } + } + + var newValue = line + "\n\n"; + if (newValue != lastValue) { + text.value = lastValue = newValue; + lastSelectionStart = lastSelectionEnd = newValue.length; + } + if (afterContextMenu) { + lastSelectionStart = text.selectionStart; + lastSelectionEnd = text.selectionEnd; + } + if ( + lastSelectionEnd != selectionEnd + || lastSelectionStart != selectionStart + || text.selectionEnd != lastSelectionEnd // on ie edge selectionEnd changes silently after the initialization + ) { + try { + text.setSelectionRange(selectionStart, selectionEnd); + lastSelectionStart = selectionStart; + lastSelectionEnd = selectionEnd; + } catch(e){} + } + inComposition = false; + }; + this.resetSelection = resetSelection; + + if (isFocused) + host.onFocus(); + + + var isAllSelected = function(text) { + return text.selectionStart === 0 && text.selectionEnd >= lastValue.length + && text.value === lastValue && lastValue + && text.selectionEnd !== lastSelectionEnd; + }; + + var onSelect = function(e) { + if (inComposition) + return; + if (copied) { + copied = false; + } else if (isAllSelected(text)) { + host.selectAll(); + resetSelection(); + } else if (isMobile && text.selectionStart != lastSelectionStart) { + resetSelection(); + } + }; + + var inputHandler = null; + this.setInputHandler = function(cb) {inputHandler = cb;}; + this.getInputHandler = function() {return inputHandler;}; + var afterContextMenu = false; + + var sendText = function(value, fromInput) { + if (afterContextMenu) + afterContextMenu = false; + if (pasted) { + resetSelection(); + if (value) + host.onPaste(value); + pasted = false; + return ""; + } else { + var selectionStart = text.selectionStart; + var selectionEnd = text.selectionEnd; + + var extendLeft = lastSelectionStart; + var extendRight = lastValue.length - lastSelectionEnd; + + var inserted = value; + var restoreStart = value.length - selectionStart; + var restoreEnd = value.length - selectionEnd; + + var i = 0; + while (extendLeft > 0 && lastValue[i] == value[i]) { + i++; + extendLeft--; + } + inserted = inserted.slice(i); + i = 1; + while (extendRight > 0 && lastValue.length - i > lastSelectionStart - 1 && lastValue[lastValue.length - i] == value[value.length - i]) { + i++; + extendRight--; + } + restoreStart -= i-1; + restoreEnd -= i-1; + var endIndex = inserted.length - i + 1; + if (endIndex < 0) { + extendLeft = -endIndex; + endIndex = 0; + } + inserted = inserted.slice(0, endIndex); + if (!fromInput && !inserted && !restoreStart && !extendLeft && !extendRight && !restoreEnd) + return ""; + sendingText = true; + var shouldReset = false; + if (useragent.isAndroid && inserted == ". ") { + inserted = " "; + shouldReset = true; + } + + if (inserted && !extendLeft && !extendRight && !restoreStart && !restoreEnd || commandMode) { + host.onTextInput(inserted); + } else { + host.onTextInput(inserted, { + extendLeft: extendLeft, + extendRight: extendRight, + restoreStart: restoreStart, + restoreEnd: restoreEnd + }); + } + sendingText = false; + + lastValue = value; + lastSelectionStart = selectionStart; + lastSelectionEnd = selectionEnd; + lastRestoreEnd = restoreEnd; + return shouldReset ? "\n" : inserted; + } + }; + var onInput = function(e) { + if (inComposition) + return onCompositionUpdate(); + if (e && e.inputType) { + if (e.inputType == "historyUndo") return host.execCommand("undo"); + if (e.inputType == "historyRedo") return host.execCommand("redo"); + } + var data = text.value; + var inserted = sendText(data, true); + if ( + data.length > MAX_LINE_LENGTH + 100 + || valueResetRegex.test(inserted) + || isMobile && lastSelectionStart < 1 && lastSelectionStart == lastSelectionEnd + ) { + resetSelection(); + } + }; + + var handleClipboardData = function(e, data, forceIEMime) { + var clipboardData = e.clipboardData || window.clipboardData; + if (!clipboardData || BROKEN_SETDATA) + return; + var mime = USE_IE_MIME_TYPE || forceIEMime ? "Text" : "text/plain"; + try { + if (data) { + return clipboardData.setData(mime, data) !== false; + } else { + return clipboardData.getData(mime); + } + } catch(e) { + if (!forceIEMime) + return handleClipboardData(e, data, true); + } + }; + + var doCopy = function(e, isCut) { + var data = host.getCopyText(); + if (!data) + return event.preventDefault(e); + + if (handleClipboardData(e, data)) { + if (isIOS) { + resetSelection(data); + copied = data; + setTimeout(function () { + copied = false; + }, 10); + } + isCut ? host.onCut() : host.onCopy(); + event.preventDefault(e); + } else { + copied = true; + text.value = data; + text.select(); + setTimeout(function(){ + copied = false; + resetSelection(); + isCut ? host.onCut() : host.onCopy(); + }); + } + }; + + var onCut = function(e) { + doCopy(e, true); + }; + + var onCopy = function(e) { + doCopy(e, false); + }; + + var onPaste = function(e) { + var data = handleClipboardData(e); + if (clipboard.pasteCancelled()) + return; + if (typeof data == "string") { + if (data) + host.onPaste(data, e); + if (useragent.isIE) + setTimeout(resetSelection); + event.preventDefault(e); + } + else { + text.value = ""; + pasted = true; + } + }; + + event.addCommandKeyListener(text, host.onCommandKey.bind(host), host); + + event.addListener(text, "select", onSelect, host); + event.addListener(text, "input", onInput, host); + + event.addListener(text, "cut", onCut, host); + event.addListener(text, "copy", onCopy, host); + event.addListener(text, "paste", onPaste, host); + if (!('oncut' in text) || !('oncopy' in text) || !('onpaste' in text)) { + event.addListener(parentNode, "keydown", function(e) { + if ((useragent.isMac && !e.metaKey) || !e.ctrlKey) + return; + + switch (e.keyCode) { + case 67: + onCopy(e); + break; + case 86: + onPaste(e); + break; + case 88: + onCut(e); + break; + } + }, host); + } + var onCompositionStart = function(e) { + if (inComposition || !host.onCompositionStart || host.$readOnly) + return; + + inComposition = {}; + + if (commandMode) + return; + + if (e.data) + inComposition.useTextareaForIME = false; + + setTimeout(onCompositionUpdate, 0); + host._signal("compositionStart"); + host.on("mousedown", cancelComposition); + + var range = host.getSelectionRange(); + range.end.row = range.start.row; + range.end.column = range.start.column; + inComposition.markerRange = range; + inComposition.selectionStart = lastSelectionStart; + host.onCompositionStart(inComposition); + + if (inComposition.useTextareaForIME) { + lastValue = text.value = ""; + lastSelectionStart = 0; + lastSelectionEnd = 0; + } + else { + if (text.msGetInputContext) + inComposition.context = text.msGetInputContext(); + if (text.getInputContext) + inComposition.context = text.getInputContext(); + } + }; + + var onCompositionUpdate = function() { + if (!inComposition || !host.onCompositionUpdate || host.$readOnly) + return; + if (commandMode) + return cancelComposition(); + + if (inComposition.useTextareaForIME) { + host.onCompositionUpdate(text.value); + } + else { + var data = text.value; + sendText(data); + if (inComposition.markerRange) { + if (inComposition.context) { + inComposition.markerRange.start.column = inComposition.selectionStart + = inComposition.context.compositionStartOffset; + } + inComposition.markerRange.end.column = inComposition.markerRange.start.column + + lastSelectionEnd - inComposition.selectionStart + lastRestoreEnd; + } + } + }; + + var onCompositionEnd = function(e) { + if (!host.onCompositionEnd || host.$readOnly) return; + inComposition = false; + host.onCompositionEnd(); + host.off("mousedown", cancelComposition); + if (e) onInput(); + }; + + + function cancelComposition() { + ignoreFocusEvents = true; + text.blur(); + text.focus(); + ignoreFocusEvents = false; + } + + var syncComposition = lang.delayedCall(onCompositionUpdate, 50).schedule.bind(null, null); + + function onKeyup(e) { + if (e.keyCode == 27 && text.value.length < text.selectionStart) { + if (!inComposition) + lastValue = text.value; + lastSelectionStart = lastSelectionEnd = -1; + resetSelection(); + } + syncComposition(); + } + + event.addListener(text, "compositionstart", onCompositionStart, host); + event.addListener(text, "compositionupdate", onCompositionUpdate, host); + event.addListener(text, "keyup", onKeyup, host); + event.addListener(text, "keydown", syncComposition, host); + event.addListener(text, "compositionend", onCompositionEnd, host); + + this.getElement = function() { + return text; + }; + this.setCommandMode = function(value) { + commandMode = value; + text.readOnly = false; + }; + + this.setReadOnly = function(readOnly) { + if (!commandMode) + text.readOnly = readOnly; + }; + + this.setCopyWithEmptySelection = function(value) { + }; + + this.onContextMenu = function(e) { + afterContextMenu = true; + resetSelection(); + host._emit("nativecontextmenu", {target: host, domEvent: e}); + this.moveToMouse(e, true); + }; + + this.moveToMouse = function(e, bringToFront) { + if (!tempStyle) + tempStyle = text.style.cssText; + text.style.cssText = (bringToFront ? "z-index:100000;" : "") + + (useragent.isIE ? "opacity:0.1;" : "") + + "text-indent: -" + (lastSelectionStart + lastSelectionEnd) * host.renderer.characterWidth * 0.5 + "px;"; + + var rect = host.container.getBoundingClientRect(); + var style = dom.computedStyle(host.container); + var top = rect.top + (parseInt(style.borderTopWidth) || 0); + var left = rect.left + (parseInt(rect.borderLeftWidth) || 0); + var maxTop = rect.bottom - top - text.clientHeight -2; + var move = function(e) { + dom.translate(text, e.clientX - left - 2, Math.min(e.clientY - top - 2, maxTop)); + }; + move(e); + + if (e.type != "mousedown") + return; + + host.renderer.$isMousePressed = true; + + clearTimeout(closeTimeout); + if (useragent.isWin) + event.capture(host.container, move, onContextMenuClose); + }; + + this.onContextMenuClose = onContextMenuClose; + var closeTimeout; + function onContextMenuClose() { + clearTimeout(closeTimeout); + closeTimeout = setTimeout(function () { + if (tempStyle) { + text.style.cssText = tempStyle; + tempStyle = ''; + } + host.renderer.$isMousePressed = false; + if (host.renderer.$keepTextAreaAtCursor) + host.renderer.$moveTextAreaToCursor(); + }, 0); + } + + var onContextMenu = function(e) { + host.textInput.onContextMenu(e); + onContextMenuClose(); + }; + event.addListener(text, "mouseup", onContextMenu, host); + event.addListener(text, "mousedown", function(e) { + e.preventDefault(); + onContextMenuClose(); + }, host); + event.addListener(host.renderer.scroller, "contextmenu", onContextMenu, host); + event.addListener(text, "contextmenu", onContextMenu, host); + + if (isIOS) + addIosSelectionHandler(parentNode, host, text); + + function addIosSelectionHandler(parentNode, host, text) { + var typingResetTimeout = null; + var typing = false; + + text.addEventListener("keydown", function (e) { + if (typingResetTimeout) clearTimeout(typingResetTimeout); + typing = true; + }, true); + + text.addEventListener("keyup", function (e) { + typingResetTimeout = setTimeout(function () { + typing = false; + }, 100); + }, true); + var detectArrowKeys = function(e) { + if (document.activeElement !== text) return; + if (typing || inComposition || host.$mouseHandler.isMousePressed) return; + + if (copied) { + return; + } + var selectionStart = text.selectionStart; + var selectionEnd = text.selectionEnd; + + var key = null; + var modifier = 0; + if (selectionStart == 0) { + key = KEYS.up; + } else if (selectionStart == 1) { + key = KEYS.home; + } else if (selectionEnd > lastSelectionEnd && lastValue[selectionEnd] == "\n") { + key = KEYS.end; + } else if (selectionStart < lastSelectionStart && lastValue[selectionStart - 1] == " ") { + key = KEYS.left; + modifier = MODS.option; + } else if ( + selectionStart < lastSelectionStart + || ( + selectionStart == lastSelectionStart + && lastSelectionEnd != lastSelectionStart + && selectionStart == selectionEnd + ) + ) { + key = KEYS.left; + } else if (selectionEnd > lastSelectionEnd && lastValue.slice(0, selectionEnd).split("\n").length > 2) { + key = KEYS.down; + } else if (selectionEnd > lastSelectionEnd && lastValue[selectionEnd - 1] == " ") { + key = KEYS.right; + modifier = MODS.option; + } else if ( + selectionEnd > lastSelectionEnd + || ( + selectionEnd == lastSelectionEnd + && lastSelectionEnd != lastSelectionStart + && selectionStart == selectionEnd + ) + ) { + key = KEYS.right; + } + + if (selectionStart !== selectionEnd) + modifier |= MODS.shift; + + if (key) { + var result = host.onCommandKey({}, modifier, key); + if (!result && host.commands) { + key = KEYS.keyCodeToString(key); + var command = host.commands.findKeyCommand(modifier, key); + if (command) + host.execCommand(command); + } + lastSelectionStart = selectionStart; + lastSelectionEnd = selectionEnd; + resetSelection(""); + } + }; + document.addEventListener("selectionchange", detectArrowKeys); + host.on("destroy", function() { + document.removeEventListener("selectionchange", detectArrowKeys); + }); + } +}; + +exports.TextInput = TextInput; +exports.$setUserAgentForTests = function(_isMobile, _isIOS) { + isMobile = _isMobile; + isIOS = _isIOS; +}; +}); + +ace.define("ace/mouse/default_handlers",["require","exports","module","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var useragent = require("../lib/useragent"); + +var DRAG_OFFSET = 0; // pixels +var SCROLL_COOLDOWN_T = 550; // milliseconds + +function DefaultHandlers(mouseHandler) { + mouseHandler.$clickSelection = null; + + var editor = mouseHandler.editor; + editor.setDefaultHandler("mousedown", this.onMouseDown.bind(mouseHandler)); + editor.setDefaultHandler("dblclick", this.onDoubleClick.bind(mouseHandler)); + editor.setDefaultHandler("tripleclick", this.onTripleClick.bind(mouseHandler)); + editor.setDefaultHandler("quadclick", this.onQuadClick.bind(mouseHandler)); + editor.setDefaultHandler("mousewheel", this.onMouseWheel.bind(mouseHandler)); + + var exports = ["select", "startSelect", "selectEnd", "selectAllEnd", "selectByWordsEnd", + "selectByLinesEnd", "dragWait", "dragWaitEnd", "focusWait"]; + + exports.forEach(function(x) { + mouseHandler[x] = this[x]; + }, this); + + mouseHandler.selectByLines = this.extendSelectionBy.bind(mouseHandler, "getLineRange"); + mouseHandler.selectByWords = this.extendSelectionBy.bind(mouseHandler, "getWordRange"); +} + +(function() { + + this.onMouseDown = function(ev) { + var inSelection = ev.inSelection(); + var pos = ev.getDocumentPosition(); + this.mousedownEvent = ev; + var editor = this.editor; + + var button = ev.getButton(); + if (button !== 0) { + var selectionRange = editor.getSelectionRange(); + var selectionEmpty = selectionRange.isEmpty(); + if (selectionEmpty || button == 1) + editor.selection.moveToPosition(pos); + if (button == 2) { + editor.textInput.onContextMenu(ev.domEvent); + if (!useragent.isMozilla) + ev.preventDefault(); + } + return; + } + + this.mousedownEvent.time = Date.now(); + if (inSelection && !editor.isFocused()) { + editor.focus(); + if (this.$focusTimeout && !this.$clickSelection && !editor.inMultiSelectMode) { + this.setState("focusWait"); + this.captureMouse(ev); + return; + } + } + + this.captureMouse(ev); + this.startSelect(pos, ev.domEvent._clicks > 1); + return ev.preventDefault(); + }; + + this.startSelect = function(pos, waitForClickSelection) { + pos = pos || this.editor.renderer.screenToTextCoordinates(this.x, this.y); + var editor = this.editor; + if (!this.mousedownEvent) return; + if (this.mousedownEvent.getShiftKey()) + editor.selection.selectToPosition(pos); + else if (!waitForClickSelection) + editor.selection.moveToPosition(pos); + if (!waitForClickSelection) + this.select(); + if (editor.renderer.scroller.setCapture) { + editor.renderer.scroller.setCapture(); + } + editor.setStyle("ace_selecting"); + this.setState("select"); + }; + + this.select = function() { + var anchor, editor = this.editor; + var cursor = editor.renderer.screenToTextCoordinates(this.x, this.y); + if (this.$clickSelection) { + var cmp = this.$clickSelection.comparePoint(cursor); + + if (cmp == -1) { + anchor = this.$clickSelection.end; + } else if (cmp == 1) { + anchor = this.$clickSelection.start; + } else { + var orientedRange = calcRangeOrientation(this.$clickSelection, cursor); + cursor = orientedRange.cursor; + anchor = orientedRange.anchor; + } + editor.selection.setSelectionAnchor(anchor.row, anchor.column); + } + editor.selection.selectToPosition(cursor); + editor.renderer.scrollCursorIntoView(); + }; + + this.extendSelectionBy = function(unitName) { + var anchor, editor = this.editor; + var cursor = editor.renderer.screenToTextCoordinates(this.x, this.y); + var range = editor.selection[unitName](cursor.row, cursor.column); + if (this.$clickSelection) { + var cmpStart = this.$clickSelection.comparePoint(range.start); + var cmpEnd = this.$clickSelection.comparePoint(range.end); + + if (cmpStart == -1 && cmpEnd <= 0) { + anchor = this.$clickSelection.end; + if (range.end.row != cursor.row || range.end.column != cursor.column) + cursor = range.start; + } else if (cmpEnd == 1 && cmpStart >= 0) { + anchor = this.$clickSelection.start; + if (range.start.row != cursor.row || range.start.column != cursor.column) + cursor = range.end; + } else if (cmpStart == -1 && cmpEnd == 1) { + cursor = range.end; + anchor = range.start; + } else { + var orientedRange = calcRangeOrientation(this.$clickSelection, cursor); + cursor = orientedRange.cursor; + anchor = orientedRange.anchor; + } + editor.selection.setSelectionAnchor(anchor.row, anchor.column); + } + editor.selection.selectToPosition(cursor); + editor.renderer.scrollCursorIntoView(); + }; + + this.selectEnd = + this.selectAllEnd = + this.selectByWordsEnd = + this.selectByLinesEnd = function() { + this.$clickSelection = null; + this.editor.unsetStyle("ace_selecting"); + if (this.editor.renderer.scroller.releaseCapture) { + this.editor.renderer.scroller.releaseCapture(); + } + }; + + this.focusWait = function() { + var distance = calcDistance(this.mousedownEvent.x, this.mousedownEvent.y, this.x, this.y); + var time = Date.now(); + + if (distance > DRAG_OFFSET || time - this.mousedownEvent.time > this.$focusTimeout) + this.startSelect(this.mousedownEvent.getDocumentPosition()); + }; + + this.onDoubleClick = function(ev) { + var pos = ev.getDocumentPosition(); + var editor = this.editor; + var session = editor.session; + + var range = session.getBracketRange(pos); + if (range) { + if (range.isEmpty()) { + range.start.column--; + range.end.column++; + } + this.setState("select"); + } else { + range = editor.selection.getWordRange(pos.row, pos.column); + this.setState("selectByWords"); + } + this.$clickSelection = range; + this.select(); + }; + + this.onTripleClick = function(ev) { + var pos = ev.getDocumentPosition(); + var editor = this.editor; + + this.setState("selectByLines"); + var range = editor.getSelectionRange(); + if (range.isMultiLine() && range.contains(pos.row, pos.column)) { + this.$clickSelection = editor.selection.getLineRange(range.start.row); + this.$clickSelection.end = editor.selection.getLineRange(range.end.row).end; + } else { + this.$clickSelection = editor.selection.getLineRange(pos.row); + } + this.select(); + }; + + this.onQuadClick = function(ev) { + var editor = this.editor; + + editor.selectAll(); + this.$clickSelection = editor.getSelectionRange(); + this.setState("selectAll"); + }; + + this.onMouseWheel = function(ev) { + if (ev.getAccelKey()) + return; + if (ev.getShiftKey() && ev.wheelY && !ev.wheelX) { + ev.wheelX = ev.wheelY; + ev.wheelY = 0; + } + + var editor = this.editor; + + if (!this.$lastScroll) + this.$lastScroll = { t: 0, vx: 0, vy: 0, allowed: 0 }; + + var prevScroll = this.$lastScroll; + var t = ev.domEvent.timeStamp; + var dt = t - prevScroll.t; + var vx = dt ? ev.wheelX / dt : prevScroll.vx; + var vy = dt ? ev.wheelY / dt : prevScroll.vy; + if (dt < SCROLL_COOLDOWN_T) { + vx = (vx + prevScroll.vx) / 2; + vy = (vy + prevScroll.vy) / 2; + } + + var direction = Math.abs(vx / vy); + + var canScroll = false; + if (direction >= 1 && editor.renderer.isScrollableBy(ev.wheelX * ev.speed, 0)) + canScroll = true; + if (direction <= 1 && editor.renderer.isScrollableBy(0, ev.wheelY * ev.speed)) + canScroll = true; + + if (canScroll) { + prevScroll.allowed = t; + } else if (t - prevScroll.allowed < SCROLL_COOLDOWN_T) { + var isSlower = Math.abs(vx) <= 1.5 * Math.abs(prevScroll.vx) + && Math.abs(vy) <= 1.5 * Math.abs(prevScroll.vy); + if (isSlower) { + canScroll = true; + prevScroll.allowed = t; + } + else { + prevScroll.allowed = 0; + } + } + + prevScroll.t = t; + prevScroll.vx = vx; + prevScroll.vy = vy; + + if (canScroll) { + editor.renderer.scrollBy(ev.wheelX * ev.speed, ev.wheelY * ev.speed); + return ev.stop(); + } + }; + +}).call(DefaultHandlers.prototype); + +exports.DefaultHandlers = DefaultHandlers; + +function calcDistance(ax, ay, bx, by) { + return Math.sqrt(Math.pow(bx - ax, 2) + Math.pow(by - ay, 2)); +} + +function calcRangeOrientation(range, cursor) { + if (range.start.row == range.end.row) + var cmp = 2 * cursor.column - range.start.column - range.end.column; + else if (range.start.row == range.end.row - 1 && !range.start.column && !range.end.column) + var cmp = cursor.column - 4; + else + var cmp = 2 * cursor.row - range.start.row - range.end.row; + + if (cmp < 0) + return {cursor: range.start, anchor: range.end}; + else + return {cursor: range.end, anchor: range.start}; +} + +}); + +ace.define("ace/tooltip",["require","exports","module","ace/lib/oop","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var dom = require("./lib/dom"); +function Tooltip (parentNode) { + this.isOpen = false; + this.$element = null; + this.$parentNode = parentNode; +} + +(function() { + this.$init = function() { + this.$element = dom.createElement("div"); + this.$element.className = "ace_tooltip"; + this.$element.style.display = "none"; + this.$parentNode.appendChild(this.$element); + return this.$element; + }; + this.getElement = function() { + return this.$element || this.$init(); + }; + this.setText = function(text) { + this.getElement().textContent = text; + }; + this.setHtml = function(html) { + this.getElement().innerHTML = html; + }; + this.setPosition = function(x, y) { + this.getElement().style.left = x + "px"; + this.getElement().style.top = y + "px"; + }; + this.setClassName = function(className) { + dom.addCssClass(this.getElement(), className); + }; + this.show = function(text, x, y) { + if (text != null) + this.setText(text); + if (x != null && y != null) + this.setPosition(x, y); + if (!this.isOpen) { + this.getElement().style.display = "block"; + this.isOpen = true; + } + }; + + this.hide = function() { + if (this.isOpen) { + this.getElement().style.display = "none"; + this.isOpen = false; + } + }; + this.getHeight = function() { + return this.getElement().offsetHeight; + }; + this.getWidth = function() { + return this.getElement().offsetWidth; + }; + + this.destroy = function() { + this.isOpen = false; + if (this.$element && this.$element.parentNode) { + this.$element.parentNode.removeChild(this.$element); + } + }; + +}).call(Tooltip.prototype); + +exports.Tooltip = Tooltip; +}); + +ace.define("ace/mouse/default_gutter_handler",["require","exports","module","ace/lib/dom","ace/lib/oop","ace/lib/event","ace/tooltip"], function(require, exports, module) { +"use strict"; +var dom = require("../lib/dom"); +var oop = require("../lib/oop"); +var event = require("../lib/event"); +var Tooltip = require("../tooltip").Tooltip; + +function GutterHandler(mouseHandler) { + var editor = mouseHandler.editor; + var gutter = editor.renderer.$gutterLayer; + var tooltip = new GutterTooltip(editor.container); + + mouseHandler.editor.setDefaultHandler("guttermousedown", function(e) { + if (!editor.isFocused() || e.getButton() != 0) + return; + var gutterRegion = gutter.getRegion(e); + + if (gutterRegion == "foldWidgets") + return; + + var row = e.getDocumentPosition().row; + var selection = editor.session.selection; + + if (e.getShiftKey()) + selection.selectTo(row, 0); + else { + if (e.domEvent.detail == 2) { + editor.selectAll(); + return e.preventDefault(); + } + mouseHandler.$clickSelection = editor.selection.getLineRange(row); + } + mouseHandler.setState("selectByLines"); + mouseHandler.captureMouse(e); + return e.preventDefault(); + }); + + + var tooltipTimeout, mouseEvent, tooltipAnnotation; + + function showTooltip() { + var row = mouseEvent.getDocumentPosition().row; + var annotation = gutter.$annotations[row]; + if (!annotation) + return hideTooltip(); + + var maxRow = editor.session.getLength(); + if (row == maxRow) { + var screenRow = editor.renderer.pixelToScreenCoordinates(0, mouseEvent.y).row; + var pos = mouseEvent.$pos; + if (screenRow > editor.session.documentToScreenRow(pos.row, pos.column)) + return hideTooltip(); + } + + if (tooltipAnnotation == annotation) + return; + tooltipAnnotation = annotation.text.join("
"); + + tooltip.setHtml(tooltipAnnotation); + tooltip.show(); + editor._signal("showGutterTooltip", tooltip); + editor.on("mousewheel", hideTooltip); + + if (mouseHandler.$tooltipFollowsMouse) { + moveTooltip(mouseEvent); + } else { + var gutterElement = mouseEvent.domEvent.target; + var rect = gutterElement.getBoundingClientRect(); + var style = tooltip.getElement().style; + style.left = rect.right + "px"; + style.top = rect.bottom + "px"; + } + } + + function hideTooltip() { + if (tooltipTimeout) + tooltipTimeout = clearTimeout(tooltipTimeout); + if (tooltipAnnotation) { + tooltip.hide(); + tooltipAnnotation = null; + editor._signal("hideGutterTooltip", tooltip); + editor.off("mousewheel", hideTooltip); + } + } + + function moveTooltip(e) { + tooltip.setPosition(e.x, e.y); + } + + mouseHandler.editor.setDefaultHandler("guttermousemove", function(e) { + var target = e.domEvent.target || e.domEvent.srcElement; + if (dom.hasCssClass(target, "ace_fold-widget")) + return hideTooltip(); + + if (tooltipAnnotation && mouseHandler.$tooltipFollowsMouse) + moveTooltip(e); + + mouseEvent = e; + if (tooltipTimeout) + return; + tooltipTimeout = setTimeout(function() { + tooltipTimeout = null; + if (mouseEvent && !mouseHandler.isMousePressed) + showTooltip(); + else + hideTooltip(); + }, 50); + }); + + event.addListener(editor.renderer.$gutter, "mouseout", function(e) { + mouseEvent = null; + if (!tooltipAnnotation || tooltipTimeout) + return; + + tooltipTimeout = setTimeout(function() { + tooltipTimeout = null; + hideTooltip(); + }, 50); + }, editor); + + editor.on("changeSession", hideTooltip); +} + +function GutterTooltip(parentNode) { + Tooltip.call(this, parentNode); +} + +oop.inherits(GutterTooltip, Tooltip); + +(function(){ + this.setPosition = function(x, y) { + var windowWidth = window.innerWidth || document.documentElement.clientWidth; + var windowHeight = window.innerHeight || document.documentElement.clientHeight; + var width = this.getWidth(); + var height = this.getHeight(); + x += 15; + y += 15; + if (x + width > windowWidth) { + x -= (x + width) - windowWidth; + } + if (y + height > windowHeight) { + y -= 20 + height; + } + Tooltip.prototype.setPosition.call(this, x, y); + }; + +}).call(GutterTooltip.prototype); + + + +exports.GutterHandler = GutterHandler; + +}); + +ace.define("ace/mouse/mouse_event",["require","exports","module","ace/lib/event","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var event = require("../lib/event"); +var useragent = require("../lib/useragent"); +var MouseEvent = exports.MouseEvent = function(domEvent, editor) { + this.domEvent = domEvent; + this.editor = editor; + + this.x = this.clientX = domEvent.clientX; + this.y = this.clientY = domEvent.clientY; + + this.$pos = null; + this.$inSelection = null; + + this.propagationStopped = false; + this.defaultPrevented = false; +}; + +(function() { + + this.stopPropagation = function() { + event.stopPropagation(this.domEvent); + this.propagationStopped = true; + }; + + this.preventDefault = function() { + event.preventDefault(this.domEvent); + this.defaultPrevented = true; + }; + + this.stop = function() { + this.stopPropagation(); + this.preventDefault(); + }; + this.getDocumentPosition = function() { + if (this.$pos) + return this.$pos; + + this.$pos = this.editor.renderer.screenToTextCoordinates(this.clientX, this.clientY); + return this.$pos; + }; + this.inSelection = function() { + if (this.$inSelection !== null) + return this.$inSelection; + + var editor = this.editor; + + + var selectionRange = editor.getSelectionRange(); + if (selectionRange.isEmpty()) + this.$inSelection = false; + else { + var pos = this.getDocumentPosition(); + this.$inSelection = selectionRange.contains(pos.row, pos.column); + } + + return this.$inSelection; + }; + this.getButton = function() { + return event.getButton(this.domEvent); + }; + this.getShiftKey = function() { + return this.domEvent.shiftKey; + }; + + this.getAccelKey = useragent.isMac + ? function() { return this.domEvent.metaKey; } + : function() { return this.domEvent.ctrlKey; }; + +}).call(MouseEvent.prototype); + +}); + +ace.define("ace/mouse/dragdrop_handler",["require","exports","module","ace/lib/dom","ace/lib/event","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var dom = require("../lib/dom"); +var event = require("../lib/event"); +var useragent = require("../lib/useragent"); + +var AUTOSCROLL_DELAY = 200; +var SCROLL_CURSOR_DELAY = 200; +var SCROLL_CURSOR_HYSTERESIS = 5; + +function DragdropHandler(mouseHandler) { + + var editor = mouseHandler.editor; + + var dragImage = dom.createElement("div"); + dragImage.style.cssText = "top:-100px;position:absolute;z-index:2147483647;opacity:0.5"; + dragImage.textContent = "\xa0"; + + var exports = ["dragWait", "dragWaitEnd", "startDrag", "dragReadyEnd", "onMouseDrag"]; + + exports.forEach(function(x) { + mouseHandler[x] = this[x]; + }, this); + editor.on("mousedown", this.onMouseDown.bind(mouseHandler)); + + var mouseTarget = editor.container; + var dragSelectionMarker, x, y; + var timerId, range; + var dragCursor, counter = 0; + var dragOperation; + var isInternal; + var autoScrollStartTime; + var cursorMovedTime; + var cursorPointOnCaretMoved; + + this.onDragStart = function(e) { + if (this.cancelDrag || !mouseTarget.draggable) { + var self = this; + setTimeout(function(){ + self.startSelect(); + self.captureMouse(e); + }, 0); + return e.preventDefault(); + } + range = editor.getSelectionRange(); + + var dataTransfer = e.dataTransfer; + dataTransfer.effectAllowed = editor.getReadOnly() ? "copy" : "copyMove"; + editor.container.appendChild(dragImage); + + dataTransfer.setDragImage && dataTransfer.setDragImage(dragImage, 0, 0); + setTimeout(function() { + editor.container.removeChild(dragImage); + }); + dataTransfer.clearData(); + dataTransfer.setData("Text", editor.session.getTextRange()); + + isInternal = true; + this.setState("drag"); + }; + + this.onDragEnd = function(e) { + mouseTarget.draggable = false; + isInternal = false; + this.setState(null); + if (!editor.getReadOnly()) { + var dropEffect = e.dataTransfer.dropEffect; + if (!dragOperation && dropEffect == "move") + editor.session.remove(editor.getSelectionRange()); + editor.$resetCursorStyle(); + } + this.editor.unsetStyle("ace_dragging"); + this.editor.renderer.setCursorStyle(""); + }; + + this.onDragEnter = function(e) { + if (editor.getReadOnly() || !canAccept(e.dataTransfer)) + return; + x = e.clientX; + y = e.clientY; + if (!dragSelectionMarker) + addDragMarker(); + counter++; + e.dataTransfer.dropEffect = dragOperation = getDropEffect(e); + return event.preventDefault(e); + }; + + this.onDragOver = function(e) { + if (editor.getReadOnly() || !canAccept(e.dataTransfer)) + return; + x = e.clientX; + y = e.clientY; + if (!dragSelectionMarker) { + addDragMarker(); + counter++; + } + if (onMouseMoveTimer !== null) + onMouseMoveTimer = null; + + e.dataTransfer.dropEffect = dragOperation = getDropEffect(e); + return event.preventDefault(e); + }; + + this.onDragLeave = function(e) { + counter--; + if (counter <= 0 && dragSelectionMarker) { + clearDragMarker(); + dragOperation = null; + return event.preventDefault(e); + } + }; + + this.onDrop = function(e) { + if (!dragCursor) + return; + var dataTransfer = e.dataTransfer; + if (isInternal) { + switch (dragOperation) { + case "move": + if (range.contains(dragCursor.row, dragCursor.column)) { + range = { + start: dragCursor, + end: dragCursor + }; + } else { + range = editor.moveText(range, dragCursor); + } + break; + case "copy": + range = editor.moveText(range, dragCursor, true); + break; + } + } else { + var dropData = dataTransfer.getData('Text'); + range = { + start: dragCursor, + end: editor.session.insert(dragCursor, dropData) + }; + editor.focus(); + dragOperation = null; + } + clearDragMarker(); + return event.preventDefault(e); + }; + + event.addListener(mouseTarget, "dragstart", this.onDragStart.bind(mouseHandler), editor); + event.addListener(mouseTarget, "dragend", this.onDragEnd.bind(mouseHandler), editor); + event.addListener(mouseTarget, "dragenter", this.onDragEnter.bind(mouseHandler), editor); + event.addListener(mouseTarget, "dragover", this.onDragOver.bind(mouseHandler), editor); + event.addListener(mouseTarget, "dragleave", this.onDragLeave.bind(mouseHandler), editor); + event.addListener(mouseTarget, "drop", this.onDrop.bind(mouseHandler), editor); + + function scrollCursorIntoView(cursor, prevCursor) { + var now = Date.now(); + var vMovement = !prevCursor || cursor.row != prevCursor.row; + var hMovement = !prevCursor || cursor.column != prevCursor.column; + if (!cursorMovedTime || vMovement || hMovement) { + editor.moveCursorToPosition(cursor); + cursorMovedTime = now; + cursorPointOnCaretMoved = {x: x, y: y}; + } else { + var distance = calcDistance(cursorPointOnCaretMoved.x, cursorPointOnCaretMoved.y, x, y); + if (distance > SCROLL_CURSOR_HYSTERESIS) { + cursorMovedTime = null; + } else if (now - cursorMovedTime >= SCROLL_CURSOR_DELAY) { + editor.renderer.scrollCursorIntoView(); + cursorMovedTime = null; + } + } + } + + function autoScroll(cursor, prevCursor) { + var now = Date.now(); + var lineHeight = editor.renderer.layerConfig.lineHeight; + var characterWidth = editor.renderer.layerConfig.characterWidth; + var editorRect = editor.renderer.scroller.getBoundingClientRect(); + var offsets = { + x: { + left: x - editorRect.left, + right: editorRect.right - x + }, + y: { + top: y - editorRect.top, + bottom: editorRect.bottom - y + } + }; + var nearestXOffset = Math.min(offsets.x.left, offsets.x.right); + var nearestYOffset = Math.min(offsets.y.top, offsets.y.bottom); + var scrollCursor = {row: cursor.row, column: cursor.column}; + if (nearestXOffset / characterWidth <= 2) { + scrollCursor.column += (offsets.x.left < offsets.x.right ? -3 : +2); + } + if (nearestYOffset / lineHeight <= 1) { + scrollCursor.row += (offsets.y.top < offsets.y.bottom ? -1 : +1); + } + var vScroll = cursor.row != scrollCursor.row; + var hScroll = cursor.column != scrollCursor.column; + var vMovement = !prevCursor || cursor.row != prevCursor.row; + if (vScroll || (hScroll && !vMovement)) { + if (!autoScrollStartTime) + autoScrollStartTime = now; + else if (now - autoScrollStartTime >= AUTOSCROLL_DELAY) + editor.renderer.scrollCursorIntoView(scrollCursor); + } else { + autoScrollStartTime = null; + } + } + + function onDragInterval() { + var prevCursor = dragCursor; + dragCursor = editor.renderer.screenToTextCoordinates(x, y); + scrollCursorIntoView(dragCursor, prevCursor); + autoScroll(dragCursor, prevCursor); + } + + function addDragMarker() { + range = editor.selection.toOrientedRange(); + dragSelectionMarker = editor.session.addMarker(range, "ace_selection", editor.getSelectionStyle()); + editor.clearSelection(); + if (editor.isFocused()) + editor.renderer.$cursorLayer.setBlinking(false); + clearInterval(timerId); + onDragInterval(); + timerId = setInterval(onDragInterval, 20); + counter = 0; + event.addListener(document, "mousemove", onMouseMove); + } + + function clearDragMarker() { + clearInterval(timerId); + editor.session.removeMarker(dragSelectionMarker); + dragSelectionMarker = null; + editor.selection.fromOrientedRange(range); + if (editor.isFocused() && !isInternal) + editor.$resetCursorStyle(); + range = null; + dragCursor = null; + counter = 0; + autoScrollStartTime = null; + cursorMovedTime = null; + event.removeListener(document, "mousemove", onMouseMove); + } + var onMouseMoveTimer = null; + function onMouseMove() { + if (onMouseMoveTimer == null) { + onMouseMoveTimer = setTimeout(function() { + if (onMouseMoveTimer != null && dragSelectionMarker) + clearDragMarker(); + }, 20); + } + } + + function canAccept(dataTransfer) { + var types = dataTransfer.types; + return !types || Array.prototype.some.call(types, function(type) { + return type == 'text/plain' || type == 'Text'; + }); + } + + function getDropEffect(e) { + var copyAllowed = ['copy', 'copymove', 'all', 'uninitialized']; + var moveAllowed = ['move', 'copymove', 'linkmove', 'all', 'uninitialized']; + + var copyModifierState = useragent.isMac ? e.altKey : e.ctrlKey; + var effectAllowed = "uninitialized"; + try { + effectAllowed = e.dataTransfer.effectAllowed.toLowerCase(); + } catch (e) {} + var dropEffect = "none"; + + if (copyModifierState && copyAllowed.indexOf(effectAllowed) >= 0) + dropEffect = "copy"; + else if (moveAllowed.indexOf(effectAllowed) >= 0) + dropEffect = "move"; + else if (copyAllowed.indexOf(effectAllowed) >= 0) + dropEffect = "copy"; + + return dropEffect; + } +} + +(function() { + + this.dragWait = function() { + var interval = Date.now() - this.mousedownEvent.time; + if (interval > this.editor.getDragDelay()) + this.startDrag(); + }; + + this.dragWaitEnd = function() { + var target = this.editor.container; + target.draggable = false; + this.startSelect(this.mousedownEvent.getDocumentPosition()); + this.selectEnd(); + }; + + this.dragReadyEnd = function(e) { + this.editor.$resetCursorStyle(); + this.editor.unsetStyle("ace_dragging"); + this.editor.renderer.setCursorStyle(""); + this.dragWaitEnd(); + }; + + this.startDrag = function(){ + this.cancelDrag = false; + var editor = this.editor; + var target = editor.container; + target.draggable = true; + editor.renderer.$cursorLayer.setBlinking(false); + editor.setStyle("ace_dragging"); + var cursorStyle = useragent.isWin ? "default" : "move"; + editor.renderer.setCursorStyle(cursorStyle); + this.setState("dragReady"); + }; + + this.onMouseDrag = function(e) { + var target = this.editor.container; + if (useragent.isIE && this.state == "dragReady") { + var distance = calcDistance(this.mousedownEvent.x, this.mousedownEvent.y, this.x, this.y); + if (distance > 3) + target.dragDrop(); + } + if (this.state === "dragWait") { + var distance = calcDistance(this.mousedownEvent.x, this.mousedownEvent.y, this.x, this.y); + if (distance > 0) { + target.draggable = false; + this.startSelect(this.mousedownEvent.getDocumentPosition()); + } + } + }; + + this.onMouseDown = function(e) { + if (!this.$dragEnabled) + return; + this.mousedownEvent = e; + var editor = this.editor; + + var inSelection = e.inSelection(); + var button = e.getButton(); + var clickCount = e.domEvent.detail || 1; + if (clickCount === 1 && button === 0 && inSelection) { + if (e.editor.inMultiSelectMode && (e.getAccelKey() || e.getShiftKey())) + return; + this.mousedownEvent.time = Date.now(); + var eventTarget = e.domEvent.target || e.domEvent.srcElement; + if ("unselectable" in eventTarget) + eventTarget.unselectable = "on"; + if (editor.getDragDelay()) { + if (useragent.isWebKit) { + this.cancelDrag = true; + var mouseTarget = editor.container; + mouseTarget.draggable = true; + } + this.setState("dragWait"); + } else { + this.startDrag(); + } + this.captureMouse(e, this.onMouseDrag.bind(this)); + e.defaultPrevented = true; + } + }; + +}).call(DragdropHandler.prototype); + + +function calcDistance(ax, ay, bx, by) { + return Math.sqrt(Math.pow(bx - ax, 2) + Math.pow(by - ay, 2)); +} + +exports.DragdropHandler = DragdropHandler; + +}); + +ace.define("ace/mouse/touch_handler",["require","exports","module","ace/mouse/mouse_event","ace/lib/event","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var MouseEvent = require("./mouse_event").MouseEvent; +var event = require("../lib/event"); +var dom = require("../lib/dom"); + +exports.addTouchListeners = function(el, editor) { + var mode = "scroll"; + var startX; + var startY; + var touchStartT; + var lastT; + var longTouchTimer; + var animationTimer; + var animationSteps = 0; + var pos; + var clickCount = 0; + var vX = 0; + var vY = 0; + var pressed; + var contextMenu; + + function createContextMenu() { + var clipboard = window.navigator && window.navigator.clipboard; + var isOpen = false; + var updateMenu = function() { + var selected = editor.getCopyText(); + var hasUndo = editor.session.getUndoManager().hasUndo(); + contextMenu.replaceChild( + dom.buildDom(isOpen ? ["span", + !selected && ["span", { class: "ace_mobile-button", action: "selectall" }, "Select All"], + selected && ["span", { class: "ace_mobile-button", action: "copy" }, "Copy"], + selected && ["span", { class: "ace_mobile-button", action: "cut" }, "Cut"], + clipboard && ["span", { class: "ace_mobile-button", action: "paste" }, "Paste"], + hasUndo && ["span", { class: "ace_mobile-button", action: "undo" }, "Undo"], + ["span", { class: "ace_mobile-button", action: "find" }, "Find"], + ["span", { class: "ace_mobile-button", action: "openCommandPallete" }, "Pallete"] + ] : ["span"]), + contextMenu.firstChild + ); + }; + var handleClick = function(e) { + var action = e.target.getAttribute("action"); + + if (action == "more" || !isOpen) { + isOpen = !isOpen; + return updateMenu(); + } + if (action == "paste") { + clipboard.readText().then(function (text) { + editor.execCommand(action, text); + }); + } + else if (action) { + if (action == "cut" || action == "copy") { + if (clipboard) + clipboard.writeText(editor.getCopyText()); + else + document.execCommand("copy"); + } + editor.execCommand(action); + } + contextMenu.firstChild.style.display = "none"; + isOpen = false; + if (action != "openCommandPallete") + editor.focus(); + }; + contextMenu = dom.buildDom(["div", + { + class: "ace_mobile-menu", + ontouchstart: function(e) { + mode = "menu"; + e.stopPropagation(); + e.preventDefault(); + editor.textInput.focus(); + }, + ontouchend: function(e) { + e.stopPropagation(); + e.preventDefault(); + handleClick(e); + }, + onclick: handleClick + }, + ["span"], + ["span", { class: "ace_mobile-button", action: "more" }, "..."] + ], editor.container); + } + function showContextMenu() { + if (!contextMenu) createContextMenu(); + var cursor = editor.selection.cursor; + var pagePos = editor.renderer.textToScreenCoordinates(cursor.row, cursor.column); + var leftOffset = editor.renderer.textToScreenCoordinates(0, 0).pageX; + var scrollLeft = editor.renderer.scrollLeft; + var rect = editor.container.getBoundingClientRect(); + contextMenu.style.top = pagePos.pageY - rect.top - 3 + "px"; + if (pagePos.pageX - rect.left < rect.width - 70) { + contextMenu.style.left = ""; + contextMenu.style.right = "10px"; + } else { + contextMenu.style.right = ""; + contextMenu.style.left = leftOffset + scrollLeft - rect.left + "px"; + } + contextMenu.style.display = ""; + contextMenu.firstChild.style.display = "none"; + editor.on("input", hideContextMenu); + } + function hideContextMenu(e) { + if (contextMenu) + contextMenu.style.display = "none"; + editor.off("input", hideContextMenu); + } + + function handleLongTap() { + longTouchTimer = null; + clearTimeout(longTouchTimer); + var range = editor.selection.getRange(); + var inSelection = range.contains(pos.row, pos.column); + if (range.isEmpty() || !inSelection) { + editor.selection.moveToPosition(pos); + editor.selection.selectWord(); + } + mode = "wait"; + showContextMenu(); + } + function switchToSelectionMode() { + longTouchTimer = null; + clearTimeout(longTouchTimer); + editor.selection.moveToPosition(pos); + var range = clickCount >= 2 + ? editor.selection.getLineRange(pos.row) + : editor.session.getBracketRange(pos); + if (range && !range.isEmpty()) { + editor.selection.setRange(range); + } else { + editor.selection.selectWord(); + } + mode = "wait"; + } + event.addListener(el, "contextmenu", function(e) { + if (!pressed) return; + var textarea = editor.textInput.getElement(); + textarea.focus(); + }, editor); + event.addListener(el, "touchstart", function (e) { + var touches = e.touches; + if (longTouchTimer || touches.length > 1) { + clearTimeout(longTouchTimer); + longTouchTimer = null; + touchStartT = -1; + mode = "zoom"; + return; + } + + pressed = editor.$mouseHandler.isMousePressed = true; + var h = editor.renderer.layerConfig.lineHeight; + var w = editor.renderer.layerConfig.lineHeight; + var t = e.timeStamp; + lastT = t; + var touchObj = touches[0]; + var x = touchObj.clientX; + var y = touchObj.clientY; + if (Math.abs(startX - x) + Math.abs(startY - y) > h) + touchStartT = -1; + + startX = e.clientX = x; + startY = e.clientY = y; + vX = vY = 0; + + var ev = new MouseEvent(e, editor); + pos = ev.getDocumentPosition(); + + if (t - touchStartT < 500 && touches.length == 1 && !animationSteps) { + clickCount++; + e.preventDefault(); + e.button = 0; + switchToSelectionMode(); + } else { + clickCount = 0; + var cursor = editor.selection.cursor; + var anchor = editor.selection.isEmpty() ? cursor : editor.selection.anchor; + + var cursorPos = editor.renderer.$cursorLayer.getPixelPosition(cursor, true); + var anchorPos = editor.renderer.$cursorLayer.getPixelPosition(anchor, true); + var rect = editor.renderer.scroller.getBoundingClientRect(); + var offsetTop = editor.renderer.layerConfig.offset; + var offsetLeft = editor.renderer.scrollLeft; + var weightedDistance = function(x, y) { + x = x / w; + y = y / h - 0.75; + return x * x + y * y; + }; + + if (e.clientX < rect.left) { + mode = "zoom"; + return; + } + + var diff1 = weightedDistance( + e.clientX - rect.left - cursorPos.left + offsetLeft, + e.clientY - rect.top - cursorPos.top + offsetTop + ); + var diff2 = weightedDistance( + e.clientX - rect.left - anchorPos.left + offsetLeft, + e.clientY - rect.top - anchorPos.top + offsetTop + ); + if (diff1 < 3.5 && diff2 < 3.5) + mode = diff1 > diff2 ? "cursor" : "anchor"; + + if (diff2 < 3.5) + mode = "anchor"; + else if (diff1 < 3.5) + mode = "cursor"; + else + mode = "scroll"; + longTouchTimer = setTimeout(handleLongTap, 450); + } + touchStartT = t; + }, editor); + + event.addListener(el, "touchend", function (e) { + pressed = editor.$mouseHandler.isMousePressed = false; + if (animationTimer) clearInterval(animationTimer); + if (mode == "zoom") { + mode = ""; + animationSteps = 0; + } else if (longTouchTimer) { + editor.selection.moveToPosition(pos); + animationSteps = 0; + showContextMenu(); + } else if (mode == "scroll") { + animate(); + hideContextMenu(); + } else { + showContextMenu(); + } + clearTimeout(longTouchTimer); + longTouchTimer = null; + }, editor); + event.addListener(el, "touchmove", function (e) { + if (longTouchTimer) { + clearTimeout(longTouchTimer); + longTouchTimer = null; + } + var touches = e.touches; + if (touches.length > 1 || mode == "zoom") return; + + var touchObj = touches[0]; + + var wheelX = startX - touchObj.clientX; + var wheelY = startY - touchObj.clientY; + + if (mode == "wait") { + if (wheelX * wheelX + wheelY * wheelY > 4) + mode = "cursor"; + else + return e.preventDefault(); + } + + startX = touchObj.clientX; + startY = touchObj.clientY; + + e.clientX = touchObj.clientX; + e.clientY = touchObj.clientY; + + var t = e.timeStamp; + var dt = t - lastT; + lastT = t; + if (mode == "scroll") { + var mouseEvent = new MouseEvent(e, editor); + mouseEvent.speed = 1; + mouseEvent.wheelX = wheelX; + mouseEvent.wheelY = wheelY; + if (10 * Math.abs(wheelX) < Math.abs(wheelY)) wheelX = 0; + if (10 * Math.abs(wheelY) < Math.abs(wheelX)) wheelY = 0; + if (dt != 0) { + vX = wheelX / dt; + vY = wheelY / dt; + } + editor._emit("mousewheel", mouseEvent); + if (!mouseEvent.propagationStopped) { + vX = vY = 0; + } + } + else { + var ev = new MouseEvent(e, editor); + var pos = ev.getDocumentPosition(); + if (mode == "cursor") + editor.selection.moveCursorToPosition(pos); + else if (mode == "anchor") + editor.selection.setSelectionAnchor(pos.row, pos.column); + editor.renderer.scrollCursorIntoView(pos); + e.preventDefault(); + } + }, editor); + + function animate() { + animationSteps += 60; + animationTimer = setInterval(function() { + if (animationSteps-- <= 0) { + clearInterval(animationTimer); + animationTimer = null; + } + if (Math.abs(vX) < 0.01) vX = 0; + if (Math.abs(vY) < 0.01) vY = 0; + if (animationSteps < 20) vX = 0.9 * vX; + if (animationSteps < 20) vY = 0.9 * vY; + var oldScrollTop = editor.session.getScrollTop(); + editor.renderer.scrollBy(10 * vX, 10 * vY); + if (oldScrollTop == editor.session.getScrollTop()) + animationSteps = 0; + }, 10); + } +}; + +}); + +ace.define("ace/lib/net",["require","exports","module","ace/lib/dom"], function(require, exports, module) { +"use strict"; +var dom = require("./dom"); + +exports.get = function (url, callback) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.onreadystatechange = function () { + if (xhr.readyState === 4) { + callback(xhr.responseText); + } + }; + xhr.send(null); +}; + +exports.loadScript = function(path, callback) { + var head = dom.getDocumentHead(); + var s = document.createElement('script'); + + s.src = path; + head.appendChild(s); + + s.onload = s.onreadystatechange = function(_, isAbort) { + if (isAbort || !s.readyState || s.readyState == "loaded" || s.readyState == "complete") { + s = s.onload = s.onreadystatechange = null; + if (!isAbort) + callback(); + } + }; +}; +exports.qualifyURL = function(url) { + var a = document.createElement('a'); + a.href = url; + return a.href; +}; + +}); + +ace.define("ace/lib/event_emitter",["require","exports","module"], function(require, exports, module) { +"use strict"; + +var EventEmitter = {}; +var stopPropagation = function() { this.propagationStopped = true; }; +var preventDefault = function() { this.defaultPrevented = true; }; + +EventEmitter._emit = +EventEmitter._dispatchEvent = function(eventName, e) { + this._eventRegistry || (this._eventRegistry = {}); + this._defaultHandlers || (this._defaultHandlers = {}); + + var listeners = this._eventRegistry[eventName] || []; + var defaultHandler = this._defaultHandlers[eventName]; + if (!listeners.length && !defaultHandler) + return; + + if (typeof e != "object" || !e) + e = {}; + + if (!e.type) + e.type = eventName; + if (!e.stopPropagation) + e.stopPropagation = stopPropagation; + if (!e.preventDefault) + e.preventDefault = preventDefault; + + listeners = listeners.slice(); + for (var i=0; i 1) + base = parts[parts.length - 2]; + var path = options[component + "Path"]; + if (path == null) { + path = options.basePath; + } else if (sep == "/") { + component = sep = ""; + } + if (path && path.slice(-1) != "/") + path += "/"; + return path + component + sep + base + this.get("suffix"); +}; + +exports.setModuleUrl = function(name, subst) { + return options.$moduleUrls[name] = subst; +}; + +exports.$loading = {}; +exports.loadModule = function(moduleName, onLoad) { + var module, moduleType; + if (Array.isArray(moduleName)) { + moduleType = moduleName[0]; + moduleName = moduleName[1]; + } + + try { + module = require(moduleName); + } catch (e) {} + if (module && !exports.$loading[moduleName]) + return onLoad && onLoad(module); + + if (!exports.$loading[moduleName]) + exports.$loading[moduleName] = []; + + exports.$loading[moduleName].push(onLoad); + + if (exports.$loading[moduleName].length > 1) + return; + + var afterLoad = function() { + require([moduleName], function(module) { + exports._emit("load.module", {name: moduleName, module: module}); + var listeners = exports.$loading[moduleName]; + exports.$loading[moduleName] = null; + listeners.forEach(function(onLoad) { + onLoad && onLoad(module); + }); + }); + }; + + if (!exports.get("packaged")) + return afterLoad(); + + net.loadScript(exports.moduleUrl(moduleName, moduleType), afterLoad); + reportErrorIfPathIsNotConfigured(); +}; + +var reportErrorIfPathIsNotConfigured = function() { + if ( + !options.basePath && !options.workerPath + && !options.modePath && !options.themePath + && !Object.keys(options.$moduleUrls).length + ) { + console.error( + "Unable to infer path to ace from script src,", + "use ace.config.set('basePath', 'path') to enable dynamic loading of modes and themes", + "or with webpack use ace/webpack-resolver" + ); + reportErrorIfPathIsNotConfigured = function() {}; + } +}; +init(true);function init(packaged) { + + if (!global || !global.document) + return; + + options.packaged = packaged || require.packaged || module.packaged || (global.define && __webpack_require__.amdD.packaged); + + var scriptOptions = {}; + var scriptUrl = ""; + var currentScript = (document.currentScript || document._currentScript ); // native or polyfill + var currentDocument = currentScript && currentScript.ownerDocument || document; + + var scripts = currentDocument.getElementsByTagName("script"); + for (var i=0; i 0){ + if (action == 0x10){ + for(i = condPos; i < ix; i++){ + levels[i] = 1; + } + condPos = -1; + } else { + condPos = -1; + } + } + cond = impTab[newState][6]; + if (cond){ + if(condPos == -1){ + condPos = ix; + } + }else{ + if (condPos > -1){ + for(i = condPos; i < ix; i++){ + levels[i] = newLevel; + } + condPos = -1; + } + } + if (charTypes[ix] == B){ + levels[ix] = 0; + } + hiLevel |= newLevel; + } + if (hasUBAT_S){ + for(i = 0; i < len; i++){ + if(charTypes[i] == S){ + levels[i] = dir; + for(var j = i - 1; j >= 0; j--){ + if(charTypes[j] == WS){ + levels[j] = dir; + }else{ + break; + } + } + } + } + } +} + +function _invertLevel(lev, levels, _array) { + if (hiLevel < lev){ + return; + } + if (lev == 1 && dir == RTL && !hasUBAT_B){ + _array.reverse(); + return; + } + var len = _array.length, start = 0, end, lo, hi, tmp; + while(start < len){ + if (levels[start] >= lev){ + end = start + 1; + while(end < len && levels[end] >= lev){ + end++; + } + for(lo = start, hi = end - 1 ; lo < hi; lo++, hi--){ + tmp = _array[lo]; + _array[lo] = _array[hi]; + _array[hi] = tmp; + } + start = end; + } + start++; + } +} + +function _getCharClass(chars, types, classes, ix) { + var cType = types[ix], wType, nType, len, i; + switch(cType){ + case L: + case R: + lastArabic = false; + case ON: + case AN: + return cType; + case EN: + return lastArabic ? AN : EN; + case AL: + lastArabic = true; + hasUBAT_AL = true; + return R; + case WS: + return ON; + case CS: + if (ix < 1 || (ix + 1) >= types.length || + ((wType = classes[ix - 1]) != EN && wType != AN) || + ((nType = types[ix + 1]) != EN && nType != AN)){ + return ON; + } + if (lastArabic){nType = AN;} + return nType == wType ? nType : ON; + case ES: + wType = ix > 0 ? classes[ix - 1] : B; + if (wType == EN && (ix + 1) < types.length && types[ix + 1] == EN){ + return EN; + } + return ON; + case ET: + if (ix > 0 && classes[ix - 1] == EN){ + return EN; + } + if (lastArabic){ + return ON; + } + i = ix + 1; + len = types.length; + while (i < len && types[i] == ET){ + i++; + } + if (i < len && types[i] == EN){ + return EN; + } + return ON; + case NSM: + len = types.length; + i = ix + 1; + while (i < len && types[i] == NSM){ + i++; + } + if (i < len){ + var c = chars[ix], rtlCandidate = (c >= 0x0591 && c <= 0x08FF) || c == 0xFB1E; + + wType = types[i]; + if (rtlCandidate && (wType == R || wType == AL)){ + return R; + } + } + + if (ix < 1 || (wType = types[ix - 1]) == B){ + return ON; + } + return classes[ix - 1]; + case B: + lastArabic = false; + hasUBAT_B = true; + return dir; + case S: + hasUBAT_S = true; + return ON; + case LRE: + case RLE: + case LRO: + case RLO: + case PDF: + lastArabic = false; + case BN: + return ON; + } +} + +function _getCharacterType( ch ) { + var uc = ch.charCodeAt(0), hi = uc >> 8; + + if (hi == 0) { + return ((uc > 0x00BF) ? L : UnicodeTBL00[uc]); + } else if (hi == 5) { + return (/[\u0591-\u05f4]/.test(ch) ? R : L); + } else if (hi == 6) { + if (/[\u0610-\u061a\u064b-\u065f\u06d6-\u06e4\u06e7-\u06ed]/.test(ch)) + return NSM; + else if (/[\u0660-\u0669\u066b-\u066c]/.test(ch)) + return AN; + else if (uc == 0x066A) + return ET; + else if (/[\u06f0-\u06f9]/.test(ch)) + return EN; + else + return AL; + } else if (hi == 0x20 && uc <= 0x205F) { + return UnicodeTBL20[uc & 0xFF]; + } else if (hi == 0xFE) { + return (uc >= 0xFE70 ? AL : ON); + } + return ON; +} + +function _isArabicDiacritics( ch ) { + return (ch >= '\u064b' && ch <= '\u0655'); +} +exports.L = L; +exports.R = R; +exports.EN = EN; +exports.ON_R = 3; +exports.AN = 4; +exports.R_H = 5; +exports.B = 6; +exports.RLE = 7; + +exports.DOT = "\xB7"; +exports.doBidiReorder = function(text, textCharTypes, isRtl) { + if (text.length < 2) + return {}; + + var chars = text.split(""), logicalFromVisual = new Array(chars.length), + bidiLevels = new Array(chars.length), levels = []; + + dir = isRtl ? RTL : LTR; + + _computeLevels(chars, levels, chars.length, textCharTypes); + + for (var i = 0; i < logicalFromVisual.length; logicalFromVisual[i] = i, i++); + + _invertLevel(2, levels, logicalFromVisual); + _invertLevel(1, levels, logicalFromVisual); + + for (var i = 0; i < logicalFromVisual.length - 1; i++) { //fix levels to reflect character width + if (textCharTypes[i] === AN) { + levels[i] = exports.AN; + } else if (levels[i] === R && ((textCharTypes[i] > AL && textCharTypes[i] < LRE) + || textCharTypes[i] === ON || textCharTypes[i] === BN)) { + levels[i] = exports.ON_R; + } else if ((i > 0 && chars[i - 1] === '\u0644') && /\u0622|\u0623|\u0625|\u0627/.test(chars[i])) { + levels[i - 1] = levels[i] = exports.R_H; + i++; + } + } + if (chars[chars.length - 1] === exports.DOT) + levels[chars.length - 1] = exports.B; + + if (chars[0] === '\u202B') + levels[0] = exports.RLE; + + for (var i = 0; i < logicalFromVisual.length; i++) { + bidiLevels[i] = levels[logicalFromVisual[i]]; + } + + return {'logicalFromVisual': logicalFromVisual, 'bidiLevels': bidiLevels}; +}; +exports.hasBidiCharacters = function(text, textCharTypes){ + var ret = false; + for (var i = 0; i < text.length; i++){ + textCharTypes[i] = _getCharacterType(text.charAt(i)); + if (!ret && (textCharTypes[i] == R || textCharTypes[i] == AL || textCharTypes[i] == AN)) + ret = true; + } + return ret; +}; +exports.getVisualFromLogicalIdx = function(logIdx, rowMap) { + for (var i = 0; i < rowMap.logicalFromVisual.length; i++) { + if (rowMap.logicalFromVisual[i] == logIdx) + return i; + } + return 0; +}; + +}); + +ace.define("ace/bidihandler",["require","exports","module","ace/lib/bidiutil","ace/lib/lang"], function(require, exports, module) { +"use strict"; + +var bidiUtil = require("./lib/bidiutil"); +var lang = require("./lib/lang"); +var bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\u202B]/; +var BidiHandler = function(session) { + this.session = session; + this.bidiMap = {}; + this.currentRow = null; + this.bidiUtil = bidiUtil; + this.charWidths = []; + this.EOL = "\xAC"; + this.showInvisibles = true; + this.isRtlDir = false; + this.$isRtl = false; + this.line = ""; + this.wrapIndent = 0; + this.EOF = "\xB6"; + this.RLE = "\u202B"; + this.contentWidth = 0; + this.fontMetrics = null; + this.rtlLineOffset = 0; + this.wrapOffset = 0; + this.isMoveLeftOperation = false; + this.seenBidi = bidiRE.test(session.getValue()); +}; + +(function() { + this.isBidiRow = function(screenRow, docRow, splitIndex) { + if (!this.seenBidi) + return false; + if (screenRow !== this.currentRow) { + this.currentRow = screenRow; + this.updateRowLine(docRow, splitIndex); + this.updateBidiMap(); + } + return this.bidiMap.bidiLevels; + }; + + this.onChange = function(delta) { + if (!this.seenBidi) { + if (delta.action == "insert" && bidiRE.test(delta.lines.join("\n"))) { + this.seenBidi = true; + this.currentRow = null; + } + } + else { + this.currentRow = null; + } + }; + + this.getDocumentRow = function() { + var docRow = 0; + var rowCache = this.session.$screenRowCache; + if (rowCache.length) { + var index = this.session.$getRowCacheIndex(rowCache, this.currentRow); + if (index >= 0) + docRow = this.session.$docRowCache[index]; + } + + return docRow; + }; + + this.getSplitIndex = function() { + var splitIndex = 0; + var rowCache = this.session.$screenRowCache; + if (rowCache.length) { + var currentIndex, prevIndex = this.session.$getRowCacheIndex(rowCache, this.currentRow); + while (this.currentRow - splitIndex > 0) { + currentIndex = this.session.$getRowCacheIndex(rowCache, this.currentRow - splitIndex - 1); + if (currentIndex !== prevIndex) + break; + + prevIndex = currentIndex; + splitIndex++; + } + } else { + splitIndex = this.currentRow; + } + + return splitIndex; + }; + + this.updateRowLine = function(docRow, splitIndex) { + if (docRow === undefined) + docRow = this.getDocumentRow(); + + var isLastRow = (docRow === this.session.getLength() - 1), + endOfLine = isLastRow ? this.EOF : this.EOL; + + this.wrapIndent = 0; + this.line = this.session.getLine(docRow); + this.isRtlDir = this.$isRtl || this.line.charAt(0) === this.RLE; + if (this.session.$useWrapMode) { + var splits = this.session.$wrapData[docRow]; + if (splits) { + if (splitIndex === undefined) + splitIndex = this.getSplitIndex(); + + if(splitIndex > 0 && splits.length) { + this.wrapIndent = splits.indent; + this.wrapOffset = this.wrapIndent * this.charWidths[bidiUtil.L]; + this.line = (splitIndex < splits.length) ? + this.line.substring(splits[splitIndex - 1], splits[splitIndex]) : + this.line.substring(splits[splits.length - 1]); + } else { + this.line = this.line.substring(0, splits[splitIndex]); + } + } + if (splitIndex == splits.length) + this.line += (this.showInvisibles) ? endOfLine : bidiUtil.DOT; + } else { + this.line += this.showInvisibles ? endOfLine : bidiUtil.DOT; + } + var session = this.session, shift = 0, size; + this.line = this.line.replace(/\t|[\u1100-\u2029, \u202F-\uFFE6]/g, function(ch, i){ + if (ch === '\t' || session.isFullWidth(ch.charCodeAt(0))) { + size = (ch === '\t') ? session.getScreenTabSize(i + shift) : 2; + shift += size - 1; + return lang.stringRepeat(bidiUtil.DOT, size); + } + return ch; + }); + + if (this.isRtlDir) { + this.fontMetrics.$main.textContent = (this.line.charAt(this.line.length - 1) == bidiUtil.DOT) ? this.line.substr(0, this.line.length - 1) : this.line; + this.rtlLineOffset = this.contentWidth - this.fontMetrics.$main.getBoundingClientRect().width; + } + }; + + this.updateBidiMap = function() { + var textCharTypes = []; + if (bidiUtil.hasBidiCharacters(this.line, textCharTypes) || this.isRtlDir) { + this.bidiMap = bidiUtil.doBidiReorder(this.line, textCharTypes, this.isRtlDir); + } else { + this.bidiMap = {}; + } + }; + this.markAsDirty = function() { + this.currentRow = null; + }; + this.updateCharacterWidths = function(fontMetrics) { + if (this.characterWidth === fontMetrics.$characterSize.width) + return; + + this.fontMetrics = fontMetrics; + var characterWidth = this.characterWidth = fontMetrics.$characterSize.width; + var bidiCharWidth = fontMetrics.$measureCharWidth("\u05d4"); + + this.charWidths[bidiUtil.L] = this.charWidths[bidiUtil.EN] = this.charWidths[bidiUtil.ON_R] = characterWidth; + this.charWidths[bidiUtil.R] = this.charWidths[bidiUtil.AN] = bidiCharWidth; + this.charWidths[bidiUtil.R_H] = bidiCharWidth * 0.45; + this.charWidths[bidiUtil.B] = this.charWidths[bidiUtil.RLE] = 0; + + this.currentRow = null; + }; + + this.setShowInvisibles = function(showInvisibles) { + this.showInvisibles = showInvisibles; + this.currentRow = null; + }; + + this.setEolChar = function(eolChar) { + this.EOL = eolChar; + }; + + this.setContentWidth = function(width) { + this.contentWidth = width; + }; + + this.isRtlLine = function(row) { + if (this.$isRtl) return true; + if (row != undefined) + return (this.session.getLine(row).charAt(0) == this.RLE); + else + return this.isRtlDir; + }; + + this.setRtlDirection = function(editor, isRtlDir) { + var cursor = editor.getCursorPosition(); + for (var row = editor.selection.getSelectionAnchor().row; row <= cursor.row; row++) { + if (!isRtlDir && editor.session.getLine(row).charAt(0) === editor.session.$bidiHandler.RLE) + editor.session.doc.removeInLine(row, 0, 1); + else if (isRtlDir && editor.session.getLine(row).charAt(0) !== editor.session.$bidiHandler.RLE) + editor.session.doc.insert({column: 0, row: row}, editor.session.$bidiHandler.RLE); + } + }; + this.getPosLeft = function(col) { + col -= this.wrapIndent; + var leftBoundary = (this.line.charAt(0) === this.RLE) ? 1 : 0; + var logicalIdx = (col > leftBoundary) ? (this.session.getOverwrite() ? col : col - 1) : leftBoundary; + var visualIdx = bidiUtil.getVisualFromLogicalIdx(logicalIdx, this.bidiMap), + levels = this.bidiMap.bidiLevels, left = 0; + + if (!this.session.getOverwrite() && col <= leftBoundary && levels[visualIdx] % 2 !== 0) + visualIdx++; + + for (var i = 0; i < visualIdx; i++) { + left += this.charWidths[levels[i]]; + } + + if (!this.session.getOverwrite() && (col > leftBoundary) && (levels[visualIdx] % 2 === 0)) + left += this.charWidths[levels[visualIdx]]; + + if (this.wrapIndent) + left += this.isRtlDir ? (-1 * this.wrapOffset) : this.wrapOffset; + + if (this.isRtlDir) + left += this.rtlLineOffset; + + return left; + }; + this.getSelections = function(startCol, endCol) { + var map = this.bidiMap, levels = map.bidiLevels, level, selections = [], offset = 0, + selColMin = Math.min(startCol, endCol) - this.wrapIndent, selColMax = Math.max(startCol, endCol) - this.wrapIndent, + isSelected = false, isSelectedPrev = false, selectionStart = 0; + + if (this.wrapIndent) + offset += this.isRtlDir ? (-1 * this.wrapOffset) : this.wrapOffset; + + for (var logIdx, visIdx = 0; visIdx < levels.length; visIdx++) { + logIdx = map.logicalFromVisual[visIdx]; + level = levels[visIdx]; + isSelected = (logIdx >= selColMin) && (logIdx < selColMax); + if (isSelected && !isSelectedPrev) { + selectionStart = offset; + } else if (!isSelected && isSelectedPrev) { + selections.push({left: selectionStart, width: offset - selectionStart}); + } + offset += this.charWidths[level]; + isSelectedPrev = isSelected; + } + + if (isSelected && (visIdx === levels.length)) { + selections.push({left: selectionStart, width: offset - selectionStart}); + } + + if(this.isRtlDir) { + for (var i = 0; i < selections.length; i++) { + selections[i].left += this.rtlLineOffset; + } + } + return selections; + }; + this.offsetToCol = function(posX) { + if(this.isRtlDir) + posX -= this.rtlLineOffset; + + var logicalIdx = 0, posX = Math.max(posX, 0), + offset = 0, visualIdx = 0, levels = this.bidiMap.bidiLevels, + charWidth = this.charWidths[levels[visualIdx]]; + + if (this.wrapIndent) + posX -= this.isRtlDir ? (-1 * this.wrapOffset) : this.wrapOffset; + + while(posX > offset + charWidth/2) { + offset += charWidth; + if(visualIdx === levels.length - 1) { + charWidth = 0; + break; + } + charWidth = this.charWidths[levels[++visualIdx]]; + } + + if (visualIdx > 0 && (levels[visualIdx - 1] % 2 !== 0) && (levels[visualIdx] % 2 === 0)){ + if(posX < offset) + visualIdx--; + logicalIdx = this.bidiMap.logicalFromVisual[visualIdx]; + + } else if (visualIdx > 0 && (levels[visualIdx - 1] % 2 === 0) && (levels[visualIdx] % 2 !== 0)){ + logicalIdx = 1 + ((posX > offset) ? this.bidiMap.logicalFromVisual[visualIdx] + : this.bidiMap.logicalFromVisual[visualIdx - 1]); + + } else if ((this.isRtlDir && visualIdx === levels.length - 1 && charWidth === 0 && (levels[visualIdx - 1] % 2 === 0)) + || (!this.isRtlDir && visualIdx === 0 && (levels[visualIdx] % 2 !== 0))){ + logicalIdx = 1 + this.bidiMap.logicalFromVisual[visualIdx]; + } else { + if (visualIdx > 0 && (levels[visualIdx - 1] % 2 !== 0) && charWidth !== 0) + visualIdx--; + logicalIdx = this.bidiMap.logicalFromVisual[visualIdx]; + } + + if (logicalIdx === 0 && this.isRtlDir) + logicalIdx++; + + return (logicalIdx + this.wrapIndent); + }; + +}).call(BidiHandler.prototype); + +exports.BidiHandler = BidiHandler; +}); + +ace.define("ace/selection",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/range"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var lang = require("./lib/lang"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var Range = require("./range").Range; +var Selection = function(session) { + this.session = session; + this.doc = session.getDocument(); + + this.clearSelection(); + this.cursor = this.lead = this.doc.createAnchor(0, 0); + this.anchor = this.doc.createAnchor(0, 0); + this.$silent = false; + + var self = this; + this.cursor.on("change", function(e) { + self.$cursorChanged = true; + if (!self.$silent) + self._emit("changeCursor"); + if (!self.$isEmpty && !self.$silent) + self._emit("changeSelection"); + if (!self.$keepDesiredColumnOnChange && e.old.column != e.value.column) + self.$desiredColumn = null; + }); + + this.anchor.on("change", function() { + self.$anchorChanged = true; + if (!self.$isEmpty && !self.$silent) + self._emit("changeSelection"); + }); +}; + +(function() { + + oop.implement(this, EventEmitter); + this.isEmpty = function() { + return this.$isEmpty || ( + this.anchor.row == this.lead.row && + this.anchor.column == this.lead.column + ); + }; + this.isMultiLine = function() { + return !this.$isEmpty && this.anchor.row != this.cursor.row; + }; + this.getCursor = function() { + return this.lead.getPosition(); + }; + this.setSelectionAnchor = function(row, column) { + this.$isEmpty = false; + this.anchor.setPosition(row, column); + }; + this.getAnchor = + this.getSelectionAnchor = function() { + if (this.$isEmpty) + return this.getSelectionLead(); + + return this.anchor.getPosition(); + }; + this.getSelectionLead = function() { + return this.lead.getPosition(); + }; + this.isBackwards = function() { + var anchor = this.anchor; + var lead = this.lead; + return (anchor.row > lead.row || (anchor.row == lead.row && anchor.column > lead.column)); + }; + this.getRange = function() { + var anchor = this.anchor; + var lead = this.lead; + + if (this.$isEmpty) + return Range.fromPoints(lead, lead); + + return this.isBackwards() + ? Range.fromPoints(lead, anchor) + : Range.fromPoints(anchor, lead); + }; + this.clearSelection = function() { + if (!this.$isEmpty) { + this.$isEmpty = true; + this._emit("changeSelection"); + } + }; + this.selectAll = function() { + this.$setSelection(0, 0, Number.MAX_VALUE, Number.MAX_VALUE); + }; + this.setRange = + this.setSelectionRange = function(range, reverse) { + var start = reverse ? range.end : range.start; + var end = reverse ? range.start : range.end; + this.$setSelection(start.row, start.column, end.row, end.column); + }; + + this.$setSelection = function(anchorRow, anchorColumn, cursorRow, cursorColumn) { + if (this.$silent) + return; + var wasEmpty = this.$isEmpty; + var wasMultiselect = this.inMultiSelectMode; + this.$silent = true; + this.$cursorChanged = this.$anchorChanged = false; + this.anchor.setPosition(anchorRow, anchorColumn); + this.cursor.setPosition(cursorRow, cursorColumn); + this.$isEmpty = !Range.comparePoints(this.anchor, this.cursor); + this.$silent = false; + if (this.$cursorChanged) + this._emit("changeCursor"); + if (this.$cursorChanged || this.$anchorChanged || wasEmpty != this.$isEmpty || wasMultiselect) + this._emit("changeSelection"); + }; + + this.$moveSelection = function(mover) { + var lead = this.lead; + if (this.$isEmpty) + this.setSelectionAnchor(lead.row, lead.column); + + mover.call(this); + }; + this.selectTo = function(row, column) { + this.$moveSelection(function() { + this.moveCursorTo(row, column); + }); + }; + this.selectToPosition = function(pos) { + this.$moveSelection(function() { + this.moveCursorToPosition(pos); + }); + }; + this.moveTo = function(row, column) { + this.clearSelection(); + this.moveCursorTo(row, column); + }; + this.moveToPosition = function(pos) { + this.clearSelection(); + this.moveCursorToPosition(pos); + }; + this.selectUp = function() { + this.$moveSelection(this.moveCursorUp); + }; + this.selectDown = function() { + this.$moveSelection(this.moveCursorDown); + }; + this.selectRight = function() { + this.$moveSelection(this.moveCursorRight); + }; + this.selectLeft = function() { + this.$moveSelection(this.moveCursorLeft); + }; + this.selectLineStart = function() { + this.$moveSelection(this.moveCursorLineStart); + }; + this.selectLineEnd = function() { + this.$moveSelection(this.moveCursorLineEnd); + }; + this.selectFileEnd = function() { + this.$moveSelection(this.moveCursorFileEnd); + }; + this.selectFileStart = function() { + this.$moveSelection(this.moveCursorFileStart); + }; + this.selectWordRight = function() { + this.$moveSelection(this.moveCursorWordRight); + }; + this.selectWordLeft = function() { + this.$moveSelection(this.moveCursorWordLeft); + }; + this.getWordRange = function(row, column) { + if (typeof column == "undefined") { + var cursor = row || this.lead; + row = cursor.row; + column = cursor.column; + } + return this.session.getWordRange(row, column); + }; + this.selectWord = function() { + this.setSelectionRange(this.getWordRange()); + }; + this.selectAWord = function() { + var cursor = this.getCursor(); + var range = this.session.getAWordRange(cursor.row, cursor.column); + this.setSelectionRange(range); + }; + + this.getLineRange = function(row, excludeLastChar) { + var rowStart = typeof row == "number" ? row : this.lead.row; + var rowEnd; + + var foldLine = this.session.getFoldLine(rowStart); + if (foldLine) { + rowStart = foldLine.start.row; + rowEnd = foldLine.end.row; + } else { + rowEnd = rowStart; + } + if (excludeLastChar === true) + return new Range(rowStart, 0, rowEnd, this.session.getLine(rowEnd).length); + else + return new Range(rowStart, 0, rowEnd + 1, 0); + }; + this.selectLine = function() { + this.setSelectionRange(this.getLineRange()); + }; + this.moveCursorUp = function() { + this.moveCursorBy(-1, 0); + }; + this.moveCursorDown = function() { + this.moveCursorBy(1, 0); + }; + this.wouldMoveIntoSoftTab = function(cursor, tabSize, direction) { + var start = cursor.column; + var end = cursor.column + tabSize; + + if (direction < 0) { + start = cursor.column - tabSize; + end = cursor.column; + } + return this.session.isTabStop(cursor) && this.doc.getLine(cursor.row).slice(start, end).split(" ").length-1 == tabSize; + }; + this.moveCursorLeft = function() { + var cursor = this.lead.getPosition(), + fold; + + if (fold = this.session.getFoldAt(cursor.row, cursor.column, -1)) { + this.moveCursorTo(fold.start.row, fold.start.column); + } else if (cursor.column === 0) { + if (cursor.row > 0) { + this.moveCursorTo(cursor.row - 1, this.doc.getLine(cursor.row - 1).length); + } + } + else { + var tabSize = this.session.getTabSize(); + if (this.wouldMoveIntoSoftTab(cursor, tabSize, -1) && !this.session.getNavigateWithinSoftTabs()) { + this.moveCursorBy(0, -tabSize); + } else { + this.moveCursorBy(0, -1); + } + } + }; + this.moveCursorRight = function() { + var cursor = this.lead.getPosition(), + fold; + if (fold = this.session.getFoldAt(cursor.row, cursor.column, 1)) { + this.moveCursorTo(fold.end.row, fold.end.column); + } + else if (this.lead.column == this.doc.getLine(this.lead.row).length) { + if (this.lead.row < this.doc.getLength() - 1) { + this.moveCursorTo(this.lead.row + 1, 0); + } + } + else { + var tabSize = this.session.getTabSize(); + var cursor = this.lead; + if (this.wouldMoveIntoSoftTab(cursor, tabSize, 1) && !this.session.getNavigateWithinSoftTabs()) { + this.moveCursorBy(0, tabSize); + } else { + this.moveCursorBy(0, 1); + } + } + }; + this.moveCursorLineStart = function() { + var row = this.lead.row; + var column = this.lead.column; + var screenRow = this.session.documentToScreenRow(row, column); + var firstColumnPosition = this.session.screenToDocumentPosition(screenRow, 0); + var beforeCursor = this.session.getDisplayLine( + row, null, firstColumnPosition.row, + firstColumnPosition.column + ); + + var leadingSpace = beforeCursor.match(/^\s*/); + if (leadingSpace[0].length != column && !this.session.$useEmacsStyleLineStart) + firstColumnPosition.column += leadingSpace[0].length; + this.moveCursorToPosition(firstColumnPosition); + }; + this.moveCursorLineEnd = function() { + var lead = this.lead; + var lineEnd = this.session.getDocumentLastRowColumnPosition(lead.row, lead.column); + if (this.lead.column == lineEnd.column) { + var line = this.session.getLine(lineEnd.row); + if (lineEnd.column == line.length) { + var textEnd = line.search(/\s+$/); + if (textEnd > 0) + lineEnd.column = textEnd; + } + } + + this.moveCursorTo(lineEnd.row, lineEnd.column); + }; + this.moveCursorFileEnd = function() { + var row = this.doc.getLength() - 1; + var column = this.doc.getLine(row).length; + this.moveCursorTo(row, column); + }; + this.moveCursorFileStart = function() { + this.moveCursorTo(0, 0); + }; + this.moveCursorLongWordRight = function() { + var row = this.lead.row; + var column = this.lead.column; + var line = this.doc.getLine(row); + var rightOfCursor = line.substring(column); + + this.session.nonTokenRe.lastIndex = 0; + this.session.tokenRe.lastIndex = 0; + var fold = this.session.getFoldAt(row, column, 1); + if (fold) { + this.moveCursorTo(fold.end.row, fold.end.column); + return; + } + if (this.session.nonTokenRe.exec(rightOfCursor)) { + column += this.session.nonTokenRe.lastIndex; + this.session.nonTokenRe.lastIndex = 0; + rightOfCursor = line.substring(column); + } + if (column >= line.length) { + this.moveCursorTo(row, line.length); + this.moveCursorRight(); + if (row < this.doc.getLength() - 1) + this.moveCursorWordRight(); + return; + } + if (this.session.tokenRe.exec(rightOfCursor)) { + column += this.session.tokenRe.lastIndex; + this.session.tokenRe.lastIndex = 0; + } + + this.moveCursorTo(row, column); + }; + this.moveCursorLongWordLeft = function() { + var row = this.lead.row; + var column = this.lead.column; + var fold; + if (fold = this.session.getFoldAt(row, column, -1)) { + this.moveCursorTo(fold.start.row, fold.start.column); + return; + } + + var str = this.session.getFoldStringAt(row, column, -1); + if (str == null) { + str = this.doc.getLine(row).substring(0, column); + } + + var leftOfCursor = lang.stringReverse(str); + this.session.nonTokenRe.lastIndex = 0; + this.session.tokenRe.lastIndex = 0; + if (this.session.nonTokenRe.exec(leftOfCursor)) { + column -= this.session.nonTokenRe.lastIndex; + leftOfCursor = leftOfCursor.slice(this.session.nonTokenRe.lastIndex); + this.session.nonTokenRe.lastIndex = 0; + } + if (column <= 0) { + this.moveCursorTo(row, 0); + this.moveCursorLeft(); + if (row > 0) + this.moveCursorWordLeft(); + return; + } + if (this.session.tokenRe.exec(leftOfCursor)) { + column -= this.session.tokenRe.lastIndex; + this.session.tokenRe.lastIndex = 0; + } + + this.moveCursorTo(row, column); + }; + + this.$shortWordEndIndex = function(rightOfCursor) { + var index = 0, ch; + var whitespaceRe = /\s/; + var tokenRe = this.session.tokenRe; + + tokenRe.lastIndex = 0; + if (this.session.tokenRe.exec(rightOfCursor)) { + index = this.session.tokenRe.lastIndex; + } else { + while ((ch = rightOfCursor[index]) && whitespaceRe.test(ch)) + index ++; + + if (index < 1) { + tokenRe.lastIndex = 0; + while ((ch = rightOfCursor[index]) && !tokenRe.test(ch)) { + tokenRe.lastIndex = 0; + index ++; + if (whitespaceRe.test(ch)) { + if (index > 2) { + index--; + break; + } else { + while ((ch = rightOfCursor[index]) && whitespaceRe.test(ch)) + index ++; + if (index > 2) + break; + } + } + } + } + } + tokenRe.lastIndex = 0; + + return index; + }; + + this.moveCursorShortWordRight = function() { + var row = this.lead.row; + var column = this.lead.column; + var line = this.doc.getLine(row); + var rightOfCursor = line.substring(column); + + var fold = this.session.getFoldAt(row, column, 1); + if (fold) + return this.moveCursorTo(fold.end.row, fold.end.column); + + if (column == line.length) { + var l = this.doc.getLength(); + do { + row++; + rightOfCursor = this.doc.getLine(row); + } while (row < l && /^\s*$/.test(rightOfCursor)); + + if (!/^\s+/.test(rightOfCursor)) + rightOfCursor = ""; + column = 0; + } + + var index = this.$shortWordEndIndex(rightOfCursor); + + this.moveCursorTo(row, column + index); + }; + + this.moveCursorShortWordLeft = function() { + var row = this.lead.row; + var column = this.lead.column; + + var fold; + if (fold = this.session.getFoldAt(row, column, -1)) + return this.moveCursorTo(fold.start.row, fold.start.column); + + var line = this.session.getLine(row).substring(0, column); + if (column === 0) { + do { + row--; + line = this.doc.getLine(row); + } while (row > 0 && /^\s*$/.test(line)); + + column = line.length; + if (!/\s+$/.test(line)) + line = ""; + } + + var leftOfCursor = lang.stringReverse(line); + var index = this.$shortWordEndIndex(leftOfCursor); + + return this.moveCursorTo(row, column - index); + }; + + this.moveCursorWordRight = function() { + if (this.session.$selectLongWords) + this.moveCursorLongWordRight(); + else + this.moveCursorShortWordRight(); + }; + + this.moveCursorWordLeft = function() { + if (this.session.$selectLongWords) + this.moveCursorLongWordLeft(); + else + this.moveCursorShortWordLeft(); + }; + this.moveCursorBy = function(rows, chars) { + var screenPos = this.session.documentToScreenPosition( + this.lead.row, + this.lead.column + ); + + var offsetX; + + if (chars === 0) { + if (rows !== 0) { + if (this.session.$bidiHandler.isBidiRow(screenPos.row, this.lead.row)) { + offsetX = this.session.$bidiHandler.getPosLeft(screenPos.column); + screenPos.column = Math.round(offsetX / this.session.$bidiHandler.charWidths[0]); + } else { + offsetX = screenPos.column * this.session.$bidiHandler.charWidths[0]; + } + } + + if (this.$desiredColumn) + screenPos.column = this.$desiredColumn; + else + this.$desiredColumn = screenPos.column; + } + + if (rows != 0 && this.session.lineWidgets && this.session.lineWidgets[this.lead.row]) { + var widget = this.session.lineWidgets[this.lead.row]; + if (rows < 0) + rows -= widget.rowsAbove || 0; + else if (rows > 0) + rows += widget.rowCount - (widget.rowsAbove || 0); + } + + var docPos = this.session.screenToDocumentPosition(screenPos.row + rows, screenPos.column, offsetX); + + if (rows !== 0 && chars === 0 && docPos.row === this.lead.row && docPos.column === this.lead.column) { + + } + this.moveCursorTo(docPos.row, docPos.column + chars, chars === 0); + }; + this.moveCursorToPosition = function(position) { + this.moveCursorTo(position.row, position.column); + }; + this.moveCursorTo = function(row, column, keepDesiredColumn) { + var fold = this.session.getFoldAt(row, column, 1); + if (fold) { + row = fold.start.row; + column = fold.start.column; + } + + this.$keepDesiredColumnOnChange = true; + var line = this.session.getLine(row); + if (/[\uDC00-\uDFFF]/.test(line.charAt(column)) && line.charAt(column - 1)) { + if (this.lead.row == row && this.lead.column == column + 1) + column = column - 1; + else + column = column + 1; + } + this.lead.setPosition(row, column); + this.$keepDesiredColumnOnChange = false; + + if (!keepDesiredColumn) + this.$desiredColumn = null; + }; + this.moveCursorToScreen = function(row, column, keepDesiredColumn) { + var pos = this.session.screenToDocumentPosition(row, column); + this.moveCursorTo(pos.row, pos.column, keepDesiredColumn); + }; + this.detach = function() { + this.lead.detach(); + this.anchor.detach(); + }; + + this.fromOrientedRange = function(range) { + this.setSelectionRange(range, range.cursor == range.start); + this.$desiredColumn = range.desiredColumn || this.$desiredColumn; + }; + + this.toOrientedRange = function(range) { + var r = this.getRange(); + if (range) { + range.start.column = r.start.column; + range.start.row = r.start.row; + range.end.column = r.end.column; + range.end.row = r.end.row; + } else { + range = r; + } + + range.cursor = this.isBackwards() ? range.start : range.end; + range.desiredColumn = this.$desiredColumn; + return range; + }; + this.getRangeOfMovements = function(func) { + var start = this.getCursor(); + try { + func(this); + var end = this.getCursor(); + return Range.fromPoints(start, end); + } catch(e) { + return Range.fromPoints(start, start); + } finally { + this.moveCursorToPosition(start); + } + }; + + this.toJSON = function() { + if (this.rangeCount) { + var data = this.ranges.map(function(r) { + var r1 = r.clone(); + r1.isBackwards = r.cursor == r.start; + return r1; + }); + } else { + var data = this.getRange(); + data.isBackwards = this.isBackwards(); + } + return data; + }; + + this.fromJSON = function(data) { + if (data.start == undefined) { + if (this.rangeList && data.length > 1) { + this.toSingleRange(data[0]); + for (var i = data.length; i--; ) { + var r = Range.fromPoints(data[i].start, data[i].end); + if (data[i].isBackwards) + r.cursor = r.start; + this.addRange(r, true); + } + return; + } else { + data = data[0]; + } + } + if (this.rangeList) + this.toSingleRange(data); + this.setSelectionRange(data, data.isBackwards); + }; + + this.isEqual = function(data) { + if ((data.length || this.rangeCount) && data.length != this.rangeCount) + return false; + if (!data.length || !this.ranges) + return this.getRange().isEqual(data); + + for (var i = this.ranges.length; i--; ) { + if (!this.ranges[i].isEqual(data[i])) + return false; + } + return true; + }; + +}).call(Selection.prototype); + +exports.Selection = Selection; +}); + +ace.define("ace/tokenizer",["require","exports","module","ace/config"], function(require, exports, module) { +"use strict"; + +var config = require("./config"); +var MAX_TOKEN_COUNT = 2000; +var Tokenizer = function(rules) { + this.states = rules; + + this.regExps = {}; + this.matchMappings = {}; + for (var key in this.states) { + var state = this.states[key]; + var ruleRegExps = []; + var matchTotal = 0; + var mapping = this.matchMappings[key] = {defaultToken: "text"}; + var flag = "g"; + + var splitterRurles = []; + for (var i = 0; i < state.length; i++) { + var rule = state[i]; + if (rule.defaultToken) + mapping.defaultToken = rule.defaultToken; + if (rule.caseInsensitive) + flag = "gi"; + if (rule.regex == null) + continue; + + if (rule.regex instanceof RegExp) + rule.regex = rule.regex.toString().slice(1, -1); + var adjustedregex = rule.regex; + var matchcount = new RegExp("(?:(" + adjustedregex + ")|(.))").exec("a").length - 2; + if (Array.isArray(rule.token)) { + if (rule.token.length == 1 || matchcount == 1) { + rule.token = rule.token[0]; + } else if (matchcount - 1 != rule.token.length) { + this.reportError("number of classes and regexp groups doesn't match", { + rule: rule, + groupCount: matchcount - 1 + }); + rule.token = rule.token[0]; + } else { + rule.tokenArray = rule.token; + rule.token = null; + rule.onMatch = this.$arrayTokens; + } + } else if (typeof rule.token == "function" && !rule.onMatch) { + if (matchcount > 1) + rule.onMatch = this.$applyToken; + else + rule.onMatch = rule.token; + } + + if (matchcount > 1) { + if (/\\\d/.test(rule.regex)) { + adjustedregex = rule.regex.replace(/\\([0-9]+)/g, function(match, digit) { + return "\\" + (parseInt(digit, 10) + matchTotal + 1); + }); + } else { + matchcount = 1; + adjustedregex = this.removeCapturingGroups(rule.regex); + } + if (!rule.splitRegex && typeof rule.token != "string") + splitterRurles.push(rule); // flag will be known only at the very end + } + + mapping[matchTotal] = i; + matchTotal += matchcount; + + ruleRegExps.push(adjustedregex); + if (!rule.onMatch) + rule.onMatch = null; + } + + if (!ruleRegExps.length) { + mapping[0] = 0; + ruleRegExps.push("$"); + } + + splitterRurles.forEach(function(rule) { + rule.splitRegex = this.createSplitterRegexp(rule.regex, flag); + }, this); + + this.regExps[key] = new RegExp("(" + ruleRegExps.join(")|(") + ")|($)", flag); + } +}; + +(function() { + this.$setMaxTokenCount = function(m) { + MAX_TOKEN_COUNT = m | 0; + }; + + this.$applyToken = function(str) { + var values = this.splitRegex.exec(str).slice(1); + var types = this.token.apply(this, values); + if (typeof types === "string") + return [{type: types, value: str}]; + + var tokens = []; + for (var i = 0, l = types.length; i < l; i++) { + if (values[i]) + tokens[tokens.length] = { + type: types[i], + value: values[i] + }; + } + return tokens; + }; + + this.$arrayTokens = function(str) { + if (!str) + return []; + var values = this.splitRegex.exec(str); + if (!values) + return "text"; + var tokens = []; + var types = this.tokenArray; + for (var i = 0, l = types.length; i < l; i++) { + if (values[i + 1]) + tokens[tokens.length] = { + type: types[i], + value: values[i + 1] + }; + } + return tokens; + }; + + this.removeCapturingGroups = function(src) { + var r = src.replace( + /\\.|\[(?:\\.|[^\\\]])*|\(\?[:=!<]|(\()/g, + function(x, y) {return y ? "(?:" : x;} + ); + return r; + }; + + this.createSplitterRegexp = function(src, flag) { + if (src.indexOf("(?=") != -1) { + var stack = 0; + var inChClass = false; + var lastCapture = {}; + src.replace(/(\\.)|(\((?:\?[=!])?)|(\))|([\[\]])/g, function( + m, esc, parenOpen, parenClose, square, index + ) { + if (inChClass) { + inChClass = square != "]"; + } else if (square) { + inChClass = true; + } else if (parenClose) { + if (stack == lastCapture.stack) { + lastCapture.end = index+1; + lastCapture.stack = -1; + } + stack--; + } else if (parenOpen) { + stack++; + if (parenOpen.length != 1) { + lastCapture.stack = stack; + lastCapture.start = index; + } + } + return m; + }); + + if (lastCapture.end != null && /^\)*$/.test(src.substr(lastCapture.end))) + src = src.substring(0, lastCapture.start) + src.substr(lastCapture.end); + } + if (src.charAt(0) != "^") src = "^" + src; + if (src.charAt(src.length - 1) != "$") src += "$"; + + return new RegExp(src, (flag||"").replace("g", "")); + }; + this.getLineTokens = function(line, startState) { + if (startState && typeof startState != "string") { + var stack = startState.slice(0); + startState = stack[0]; + if (startState === "#tmp") { + stack.shift(); + startState = stack.shift(); + } + } else + var stack = []; + + var currentState = startState || "start"; + var state = this.states[currentState]; + if (!state) { + currentState = "start"; + state = this.states[currentState]; + } + var mapping = this.matchMappings[currentState]; + var re = this.regExps[currentState]; + re.lastIndex = 0; + + var match, tokens = []; + var lastIndex = 0; + var matchAttempts = 0; + + var token = {type: null, value: ""}; + + while (match = re.exec(line)) { + var type = mapping.defaultToken; + var rule = null; + var value = match[0]; + var index = re.lastIndex; + + if (index - value.length > lastIndex) { + var skipped = line.substring(lastIndex, index - value.length); + if (token.type == type) { + token.value += skipped; + } else { + if (token.type) + tokens.push(token); + token = {type: type, value: skipped}; + } + } + + for (var i = 0; i < match.length-2; i++) { + if (match[i + 1] === undefined) + continue; + + rule = state[mapping[i]]; + + if (rule.onMatch) + type = rule.onMatch(value, currentState, stack, line); + else + type = rule.token; + + if (rule.next) { + if (typeof rule.next == "string") { + currentState = rule.next; + } else { + currentState = rule.next(currentState, stack); + } + + state = this.states[currentState]; + if (!state) { + this.reportError("state doesn't exist", currentState); + currentState = "start"; + state = this.states[currentState]; + } + mapping = this.matchMappings[currentState]; + lastIndex = index; + re = this.regExps[currentState]; + re.lastIndex = index; + } + if (rule.consumeLineEnd) + lastIndex = index; + break; + } + + if (value) { + if (typeof type === "string") { + if ((!rule || rule.merge !== false) && token.type === type) { + token.value += value; + } else { + if (token.type) + tokens.push(token); + token = {type: type, value: value}; + } + } else if (type) { + if (token.type) + tokens.push(token); + token = {type: null, value: ""}; + for (var i = 0; i < type.length; i++) + tokens.push(type[i]); + } + } + + if (lastIndex == line.length) + break; + + lastIndex = index; + + if (matchAttempts++ > MAX_TOKEN_COUNT) { + if (matchAttempts > 2 * line.length) { + this.reportError("infinite loop with in ace tokenizer", { + startState: startState, + line: line + }); + } + while (lastIndex < line.length) { + if (token.type) + tokens.push(token); + token = { + value: line.substring(lastIndex, lastIndex += 500), + type: "overflow" + }; + } + currentState = "start"; + stack = []; + break; + } + } + + if (token.type) + tokens.push(token); + + if (stack.length > 1) { + if (stack[0] !== currentState) + stack.unshift("#tmp", currentState); + } + return { + tokens : tokens, + state : stack.length ? stack : currentState + }; + }; + + this.reportError = config.reportError; + +}).call(Tokenizer.prototype); + +exports.Tokenizer = Tokenizer; +}); + +ace.define("ace/mode/text_highlight_rules",["require","exports","module","ace/lib/lang"], function(require, exports, module) { +"use strict"; + +var lang = require("../lib/lang"); + +var TextHighlightRules = function() { + + this.$rules = { + "start" : [{ + token : "empty_line", + regex : '^$' + }, { + defaultToken : "text" + }] + }; +}; + +(function() { + + this.addRules = function(rules, prefix) { + if (!prefix) { + for (var key in rules) + this.$rules[key] = rules[key]; + return; + } + for (var key in rules) { + var state = rules[key]; + for (var i = 0; i < state.length; i++) { + var rule = state[i]; + if (rule.next || rule.onMatch) { + if (typeof rule.next == "string") { + if (rule.next.indexOf(prefix) !== 0) + rule.next = prefix + rule.next; + } + if (rule.nextState && rule.nextState.indexOf(prefix) !== 0) + rule.nextState = prefix + rule.nextState; + } + } + this.$rules[prefix + key] = state; + } + }; + + this.getRules = function() { + return this.$rules; + }; + + this.embedRules = function (HighlightRules, prefix, escapeRules, states, append) { + var embedRules = typeof HighlightRules == "function" + ? new HighlightRules().getRules() + : HighlightRules; + if (states) { + for (var i = 0; i < states.length; i++) + states[i] = prefix + states[i]; + } else { + states = []; + for (var key in embedRules) + states.push(prefix + key); + } + + this.addRules(embedRules, prefix); + + if (escapeRules) { + var addRules = Array.prototype[append ? "push" : "unshift"]; + for (var i = 0; i < states.length; i++) + addRules.apply(this.$rules[states[i]], lang.deepCopy(escapeRules)); + } + + if (!this.$embeds) + this.$embeds = []; + this.$embeds.push(prefix); + }; + + this.getEmbeds = function() { + return this.$embeds; + }; + + var pushState = function(currentState, stack) { + if (currentState != "start" || stack.length) + stack.unshift(this.nextState, currentState); + return this.nextState; + }; + var popState = function(currentState, stack) { + stack.shift(); + return stack.shift() || "start"; + }; + + this.normalizeRules = function() { + var id = 0; + var rules = this.$rules; + function processState(key) { + var state = rules[key]; + state.processed = true; + for (var i = 0; i < state.length; i++) { + var rule = state[i]; + var toInsert = null; + if (Array.isArray(rule)) { + toInsert = rule; + rule = {}; + } + if (!rule.regex && rule.start) { + rule.regex = rule.start; + if (!rule.next) + rule.next = []; + rule.next.push({ + defaultToken: rule.token + }, { + token: rule.token + ".end", + regex: rule.end || rule.start, + next: "pop" + }); + rule.token = rule.token + ".start"; + rule.push = true; + } + var next = rule.next || rule.push; + if (next && Array.isArray(next)) { + var stateName = rule.stateName; + if (!stateName) { + stateName = rule.token; + if (typeof stateName != "string") + stateName = stateName[0] || ""; + if (rules[stateName]) + stateName += id++; + } + rules[stateName] = next; + rule.next = stateName; + processState(stateName); + } else if (next == "pop") { + rule.next = popState; + } + + if (rule.push) { + rule.nextState = rule.next || rule.push; + rule.next = pushState; + delete rule.push; + } + + if (rule.rules) { + for (var r in rule.rules) { + if (rules[r]) { + if (rules[r].push) + rules[r].push.apply(rules[r], rule.rules[r]); + } else { + rules[r] = rule.rules[r]; + } + } + } + var includeName = typeof rule == "string" ? rule : rule.include; + if (includeName) { + if (Array.isArray(includeName)) + toInsert = includeName.map(function(x) { return rules[x]; }); + else + toInsert = rules[includeName]; + } + + if (toInsert) { + var args = [i, 1].concat(toInsert); + if (rule.noEscape) + args = args.filter(function(x) {return !x.next;}); + state.splice.apply(state, args); + i--; + } + + if (rule.keywordMap) { + rule.token = this.createKeywordMapper( + rule.keywordMap, rule.defaultToken || "text", rule.caseInsensitive + ); + delete rule.defaultToken; + } + } + } + Object.keys(rules).forEach(processState, this); + }; + + this.createKeywordMapper = function(map, defaultToken, ignoreCase, splitChar) { + var keywords = Object.create(null); + this.$keywordList = []; + Object.keys(map).forEach(function(className) { + var a = map[className]; + var list = a.split(splitChar || "|"); + for (var i = list.length; i--; ) { + var word = list[i]; + this.$keywordList.push(word); + if (ignoreCase) + word = word.toLowerCase(); + keywords[word] = className; + } + }, this); + map = null; + return ignoreCase + ? function(value) {return keywords[value.toLowerCase()] || defaultToken; } + : function(value) {return keywords[value] || defaultToken; }; + }; + + this.getKeywords = function() { + return this.$keywords; + }; + +}).call(TextHighlightRules.prototype); + +exports.TextHighlightRules = TextHighlightRules; +}); + +ace.define("ace/mode/behaviour",["require","exports","module"], function(require, exports, module) { +"use strict"; + +var Behaviour = function() { + this.$behaviours = {}; +}; + +(function () { + + this.add = function (name, action, callback) { + switch (undefined) { + case this.$behaviours: + this.$behaviours = {}; + case this.$behaviours[name]: + this.$behaviours[name] = {}; + } + this.$behaviours[name][action] = callback; + }; + + this.addBehaviours = function (behaviours) { + for (var key in behaviours) { + for (var action in behaviours[key]) { + this.add(key, action, behaviours[key][action]); + } + } + }; + + this.remove = function (name) { + if (this.$behaviours && this.$behaviours[name]) { + delete this.$behaviours[name]; + } + }; + + this.inherit = function (mode, filter) { + if (typeof mode === "function") { + var behaviours = new mode().getBehaviours(filter); + } else { + var behaviours = mode.getBehaviours(filter); + } + this.addBehaviours(behaviours); + }; + + this.getBehaviours = function (filter) { + if (!filter) { + return this.$behaviours; + } else { + var ret = {}; + for (var i = 0; i < filter.length; i++) { + if (this.$behaviours[filter[i]]) { + ret[filter[i]] = this.$behaviours[filter[i]]; + } + } + return ret; + } + }; + +}).call(Behaviour.prototype); + +exports.Behaviour = Behaviour; +}); + +ace.define("ace/token_iterator",["require","exports","module","ace/range"], function(require, exports, module) { +"use strict"; + +var Range = require("./range").Range; +var TokenIterator = function(session, initialRow, initialColumn) { + this.$session = session; + this.$row = initialRow; + this.$rowTokens = session.getTokens(initialRow); + + var token = session.getTokenAt(initialRow, initialColumn); + this.$tokenIndex = token ? token.index : -1; +}; + +(function() { + this.stepBackward = function() { + this.$tokenIndex -= 1; + + while (this.$tokenIndex < 0) { + this.$row -= 1; + if (this.$row < 0) { + this.$row = 0; + return null; + } + + this.$rowTokens = this.$session.getTokens(this.$row); + this.$tokenIndex = this.$rowTokens.length - 1; + } + + return this.$rowTokens[this.$tokenIndex]; + }; + this.stepForward = function() { + this.$tokenIndex += 1; + var rowCount; + while (this.$tokenIndex >= this.$rowTokens.length) { + this.$row += 1; + if (!rowCount) + rowCount = this.$session.getLength(); + if (this.$row >= rowCount) { + this.$row = rowCount - 1; + return null; + } + + this.$rowTokens = this.$session.getTokens(this.$row); + this.$tokenIndex = 0; + } + + return this.$rowTokens[this.$tokenIndex]; + }; + this.getCurrentToken = function () { + return this.$rowTokens[this.$tokenIndex]; + }; + this.getCurrentTokenRow = function () { + return this.$row; + }; + this.getCurrentTokenColumn = function() { + var rowTokens = this.$rowTokens; + var tokenIndex = this.$tokenIndex; + var column = rowTokens[tokenIndex].start; + if (column !== undefined) + return column; + + column = 0; + while (tokenIndex > 0) { + tokenIndex -= 1; + column += rowTokens[tokenIndex].value.length; + } + + return column; + }; + this.getCurrentTokenPosition = function() { + return {row: this.$row, column: this.getCurrentTokenColumn()}; + }; + this.getCurrentTokenRange = function() { + var token = this.$rowTokens[this.$tokenIndex]; + var column = this.getCurrentTokenColumn(); + return new Range(this.$row, column, this.$row, column + token.value.length); + }; + +}).call(TokenIterator.prototype); + +exports.TokenIterator = TokenIterator; +}); + +ace.define("ace/mode/behaviour/cstyle",["require","exports","module","ace/lib/oop","ace/mode/behaviour","ace/token_iterator","ace/lib/lang"], function(require, exports, module) { +"use strict"; + +var oop = require("../../lib/oop"); +var Behaviour = require("../behaviour").Behaviour; +var TokenIterator = require("../../token_iterator").TokenIterator; +var lang = require("../../lib/lang"); + +var SAFE_INSERT_IN_TOKENS = + ["text", "paren.rparen", "rparen", "paren", "punctuation.operator"]; +var SAFE_INSERT_BEFORE_TOKENS = + ["text", "paren.rparen", "rparen", "paren", "punctuation.operator", "comment"]; + +var context; +var contextCache = {}; +var defaultQuotes = {'"' : '"', "'" : "'"}; + +var initContext = function(editor) { + var id = -1; + if (editor.multiSelect) { + id = editor.selection.index; + if (contextCache.rangeCount != editor.multiSelect.rangeCount) + contextCache = {rangeCount: editor.multiSelect.rangeCount}; + } + if (contextCache[id]) + return context = contextCache[id]; + context = contextCache[id] = { + autoInsertedBrackets: 0, + autoInsertedRow: -1, + autoInsertedLineEnd: "", + maybeInsertedBrackets: 0, + maybeInsertedRow: -1, + maybeInsertedLineStart: "", + maybeInsertedLineEnd: "" + }; +}; + +var getWrapped = function(selection, selected, opening, closing) { + var rowDiff = selection.end.row - selection.start.row; + return { + text: opening + selected + closing, + selection: [ + 0, + selection.start.column + 1, + rowDiff, + selection.end.column + (rowDiff ? 0 : 1) + ] + }; +}; + +var CstyleBehaviour = function(options) { + this.add("braces", "insertion", function(state, action, editor, session, text) { + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + if (text == '{') { + initContext(editor); + var selection = editor.getSelectionRange(); + var selected = session.doc.getTextRange(selection); + if (selected !== "" && selected !== "{" && editor.getWrapBehavioursEnabled()) { + return getWrapped(selection, selected, '{', '}'); + } else if (CstyleBehaviour.isSaneInsertion(editor, session)) { + if (/[\]\}\)]/.test(line[cursor.column]) || editor.inMultiSelectMode || options && options.braces) { + CstyleBehaviour.recordAutoInsert(editor, session, "}"); + return { + text: '{}', + selection: [1, 1] + }; + } else { + CstyleBehaviour.recordMaybeInsert(editor, session, "{"); + return { + text: '{', + selection: [1, 1] + }; + } + } + } else if (text == '}') { + initContext(editor); + var rightChar = line.substring(cursor.column, cursor.column + 1); + if (rightChar == '}') { + var matching = session.$findOpeningBracket('}', {column: cursor.column + 1, row: cursor.row}); + if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) { + CstyleBehaviour.popAutoInsertedClosing(); + return { + text: '', + selection: [1, 1] + }; + } + } + } else if (text == "\n" || text == "\r\n") { + initContext(editor); + var closing = ""; + if (CstyleBehaviour.isMaybeInsertedClosing(cursor, line)) { + closing = lang.stringRepeat("}", context.maybeInsertedBrackets); + CstyleBehaviour.clearMaybeInsertedClosing(); + } + var rightChar = line.substring(cursor.column, cursor.column + 1); + if (rightChar === '}') { + var openBracePos = session.findMatchingBracket({row: cursor.row, column: cursor.column+1}, '}'); + if (!openBracePos) + return null; + var next_indent = this.$getIndent(session.getLine(openBracePos.row)); + } else if (closing) { + var next_indent = this.$getIndent(line); + } else { + CstyleBehaviour.clearMaybeInsertedClosing(); + return; + } + var indent = next_indent + session.getTabString(); + + return { + text: '\n' + indent + '\n' + next_indent + closing, + selection: [1, indent.length, 1, indent.length] + }; + } else { + CstyleBehaviour.clearMaybeInsertedClosing(); + } + }); + + this.add("braces", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && selected == '{') { + initContext(editor); + var line = session.doc.getLine(range.start.row); + var rightChar = line.substring(range.end.column, range.end.column + 1); + if (rightChar == '}') { + range.end.column++; + return range; + } else { + context.maybeInsertedBrackets--; + } + } + }); + + this.add("parens", "insertion", function(state, action, editor, session, text) { + if (text == '(') { + initContext(editor); + var selection = editor.getSelectionRange(); + var selected = session.doc.getTextRange(selection); + if (selected !== "" && editor.getWrapBehavioursEnabled()) { + return getWrapped(selection, selected, '(', ')'); + } else if (CstyleBehaviour.isSaneInsertion(editor, session)) { + CstyleBehaviour.recordAutoInsert(editor, session, ")"); + return { + text: '()', + selection: [1, 1] + }; + } + } else if (text == ')') { + initContext(editor); + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + var rightChar = line.substring(cursor.column, cursor.column + 1); + if (rightChar == ')') { + var matching = session.$findOpeningBracket(')', {column: cursor.column + 1, row: cursor.row}); + if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) { + CstyleBehaviour.popAutoInsertedClosing(); + return { + text: '', + selection: [1, 1] + }; + } + } + } + }); + + this.add("parens", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && selected == '(') { + initContext(editor); + var line = session.doc.getLine(range.start.row); + var rightChar = line.substring(range.start.column + 1, range.start.column + 2); + if (rightChar == ')') { + range.end.column++; + return range; + } + } + }); + + this.add("brackets", "insertion", function(state, action, editor, session, text) { + if (text == '[') { + initContext(editor); + var selection = editor.getSelectionRange(); + var selected = session.doc.getTextRange(selection); + if (selected !== "" && editor.getWrapBehavioursEnabled()) { + return getWrapped(selection, selected, '[', ']'); + } else if (CstyleBehaviour.isSaneInsertion(editor, session)) { + CstyleBehaviour.recordAutoInsert(editor, session, "]"); + return { + text: '[]', + selection: [1, 1] + }; + } + } else if (text == ']') { + initContext(editor); + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + var rightChar = line.substring(cursor.column, cursor.column + 1); + if (rightChar == ']') { + var matching = session.$findOpeningBracket(']', {column: cursor.column + 1, row: cursor.row}); + if (matching !== null && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) { + CstyleBehaviour.popAutoInsertedClosing(); + return { + text: '', + selection: [1, 1] + }; + } + } + } + }); + + this.add("brackets", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && selected == '[') { + initContext(editor); + var line = session.doc.getLine(range.start.row); + var rightChar = line.substring(range.start.column + 1, range.start.column + 2); + if (rightChar == ']') { + range.end.column++; + return range; + } + } + }); + + this.add("string_dquotes", "insertion", function(state, action, editor, session, text) { + var quotes = session.$mode.$quotes || defaultQuotes; + if (text.length == 1 && quotes[text]) { + if (this.lineCommentStart && this.lineCommentStart.indexOf(text) != -1) + return; + initContext(editor); + var quote = text; + var selection = editor.getSelectionRange(); + var selected = session.doc.getTextRange(selection); + if (selected !== "" && (selected.length != 1 || !quotes[selected]) && editor.getWrapBehavioursEnabled()) { + return getWrapped(selection, selected, quote, quote); + } else if (!selected) { + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + var leftChar = line.substring(cursor.column-1, cursor.column); + var rightChar = line.substring(cursor.column, cursor.column + 1); + + var token = session.getTokenAt(cursor.row, cursor.column); + var rightToken = session.getTokenAt(cursor.row, cursor.column + 1); + if (leftChar == "\\" && token && /escape/.test(token.type)) + return null; + + var stringBefore = token && /string|escape/.test(token.type); + var stringAfter = !rightToken || /string|escape/.test(rightToken.type); + + var pair; + if (rightChar == quote) { + pair = stringBefore !== stringAfter; + if (pair && /string\.end/.test(rightToken.type)) + pair = false; + } else { + if (stringBefore && !stringAfter) + return null; // wrap string with different quote + if (stringBefore && stringAfter) + return null; // do not pair quotes inside strings + var wordRe = session.$mode.tokenRe; + wordRe.lastIndex = 0; + var isWordBefore = wordRe.test(leftChar); + wordRe.lastIndex = 0; + var isWordAfter = wordRe.test(leftChar); + if (isWordBefore || isWordAfter) + return null; // before or after alphanumeric + if (rightChar && !/[\s;,.})\]\\]/.test(rightChar)) + return null; // there is rightChar and it isn't closing + var charBefore = line[cursor.column - 2]; + if (leftChar == quote && (charBefore == quote || wordRe.test(charBefore))) + return null; + pair = true; + } + return { + text: pair ? quote + quote : "", + selection: [1,1] + }; + } + } + }); + + this.add("string_dquotes", "deletion", function(state, action, editor, session, range) { + var quotes = session.$mode.$quotes || defaultQuotes; + + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && quotes.hasOwnProperty(selected)) { + initContext(editor); + var line = session.doc.getLine(range.start.row); + var rightChar = line.substring(range.start.column + 1, range.start.column + 2); + if (rightChar == selected) { + range.end.column++; + return range; + } + } + }); + +}; + + +CstyleBehaviour.isSaneInsertion = function(editor, session) { + var cursor = editor.getCursorPosition(); + var iterator = new TokenIterator(session, cursor.row, cursor.column); + if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) { + if (/[)}\]]/.test(editor.session.getLine(cursor.row)[cursor.column])) + return true; + var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1); + if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) + return false; + } + iterator.stepForward(); + return iterator.getCurrentTokenRow() !== cursor.row || + this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS); +}; + +CstyleBehaviour.$matchTokenType = function(token, types) { + return types.indexOf(token.type || token) > -1; +}; + +CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) { + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + if (!this.isAutoInsertedClosing(cursor, line, context.autoInsertedLineEnd[0])) + context.autoInsertedBrackets = 0; + context.autoInsertedRow = cursor.row; + context.autoInsertedLineEnd = bracket + line.substr(cursor.column); + context.autoInsertedBrackets++; +}; + +CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) { + var cursor = editor.getCursorPosition(); + var line = session.doc.getLine(cursor.row); + if (!this.isMaybeInsertedClosing(cursor, line)) + context.maybeInsertedBrackets = 0; + context.maybeInsertedRow = cursor.row; + context.maybeInsertedLineStart = line.substr(0, cursor.column) + bracket; + context.maybeInsertedLineEnd = line.substr(cursor.column); + context.maybeInsertedBrackets++; +}; + +CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) { + return context.autoInsertedBrackets > 0 && + cursor.row === context.autoInsertedRow && + bracket === context.autoInsertedLineEnd[0] && + line.substr(cursor.column) === context.autoInsertedLineEnd; +}; + +CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) { + return context.maybeInsertedBrackets > 0 && + cursor.row === context.maybeInsertedRow && + line.substr(cursor.column) === context.maybeInsertedLineEnd && + line.substr(0, cursor.column) == context.maybeInsertedLineStart; +}; + +CstyleBehaviour.popAutoInsertedClosing = function() { + context.autoInsertedLineEnd = context.autoInsertedLineEnd.substr(1); + context.autoInsertedBrackets--; +}; + +CstyleBehaviour.clearMaybeInsertedClosing = function() { + if (context) { + context.maybeInsertedBrackets = 0; + context.maybeInsertedRow = -1; + } +}; + + + +oop.inherits(CstyleBehaviour, Behaviour); + +exports.CstyleBehaviour = CstyleBehaviour; +}); + +ace.define("ace/unicode",["require","exports","module"], function(require, exports, module) { +"use strict"; +var wordChars = [48,9,8,25,5,0,2,25,48,0,11,0,5,0,6,22,2,30,2,457,5,11,15,4,8,0,2,0,18,116,2,1,3,3,9,0,2,2,2,0,2,19,2,82,2,138,2,4,3,155,12,37,3,0,8,38,10,44,2,0,2,1,2,1,2,0,9,26,6,2,30,10,7,61,2,9,5,101,2,7,3,9,2,18,3,0,17,58,3,100,15,53,5,0,6,45,211,57,3,18,2,5,3,11,3,9,2,1,7,6,2,2,2,7,3,1,3,21,2,6,2,0,4,3,3,8,3,1,3,3,9,0,5,1,2,4,3,11,16,2,2,5,5,1,3,21,2,6,2,1,2,1,2,1,3,0,2,4,5,1,3,2,4,0,8,3,2,0,8,15,12,2,2,8,2,2,2,21,2,6,2,1,2,4,3,9,2,2,2,2,3,0,16,3,3,9,18,2,2,7,3,1,3,21,2,6,2,1,2,4,3,8,3,1,3,2,9,1,5,1,2,4,3,9,2,0,17,1,2,5,4,2,2,3,4,1,2,0,2,1,4,1,4,2,4,11,5,4,4,2,2,3,3,0,7,0,15,9,18,2,2,7,2,2,2,22,2,9,2,4,4,7,2,2,2,3,8,1,2,1,7,3,3,9,19,1,2,7,2,2,2,22,2,9,2,4,3,8,2,2,2,3,8,1,8,0,2,3,3,9,19,1,2,7,2,2,2,22,2,15,4,7,2,2,2,3,10,0,9,3,3,9,11,5,3,1,2,17,4,23,2,8,2,0,3,6,4,0,5,5,2,0,2,7,19,1,14,57,6,14,2,9,40,1,2,0,3,1,2,0,3,0,7,3,2,6,2,2,2,0,2,0,3,1,2,12,2,2,3,4,2,0,2,5,3,9,3,1,35,0,24,1,7,9,12,0,2,0,2,0,5,9,2,35,5,19,2,5,5,7,2,35,10,0,58,73,7,77,3,37,11,42,2,0,4,328,2,3,3,6,2,0,2,3,3,40,2,3,3,32,2,3,3,6,2,0,2,3,3,14,2,56,2,3,3,66,5,0,33,15,17,84,13,619,3,16,2,25,6,74,22,12,2,6,12,20,12,19,13,12,2,2,2,1,13,51,3,29,4,0,5,1,3,9,34,2,3,9,7,87,9,42,6,69,11,28,4,11,5,11,11,39,3,4,12,43,5,25,7,10,38,27,5,62,2,28,3,10,7,9,14,0,89,75,5,9,18,8,13,42,4,11,71,55,9,9,4,48,83,2,2,30,14,230,23,280,3,5,3,37,3,5,3,7,2,0,2,0,2,0,2,30,3,52,2,6,2,0,4,2,2,6,4,3,3,5,5,12,6,2,2,6,67,1,20,0,29,0,14,0,17,4,60,12,5,0,4,11,18,0,5,0,3,9,2,0,4,4,7,0,2,0,2,0,2,3,2,10,3,3,6,4,5,0,53,1,2684,46,2,46,2,132,7,6,15,37,11,53,10,0,17,22,10,6,2,6,2,6,2,6,2,6,2,6,2,6,2,6,2,31,48,0,470,1,36,5,2,4,6,1,5,85,3,1,3,2,2,89,2,3,6,40,4,93,18,23,57,15,513,6581,75,20939,53,1164,68,45,3,268,4,27,21,31,3,13,13,1,2,24,9,69,11,1,38,8,3,102,3,1,111,44,25,51,13,68,12,9,7,23,4,0,5,45,3,35,13,28,4,64,15,10,39,54,10,13,3,9,7,22,4,1,5,66,25,2,227,42,2,1,3,9,7,11171,13,22,5,48,8453,301,3,61,3,105,39,6,13,4,6,11,2,12,2,4,2,0,2,1,2,1,2,107,34,362,19,63,3,53,41,11,5,15,17,6,13,1,25,2,33,4,2,134,20,9,8,25,5,0,2,25,12,88,4,5,3,5,3,5,3,2]; + +var code = 0; +var str = []; +for (var i = 0; i < wordChars.length; i += 2) { + str.push(code += wordChars[i]); + if (wordChars[i + 1]) + str.push(45, code += wordChars[i + 1]); +} + +exports.wordChars = String.fromCharCode.apply(null, str); + +}); + +ace.define("ace/mode/text",["require","exports","module","ace/config","ace/tokenizer","ace/mode/text_highlight_rules","ace/mode/behaviour/cstyle","ace/unicode","ace/lib/lang","ace/token_iterator","ace/range"], function(require, exports, module) { +"use strict"; +var config = require("../config"); + +var Tokenizer = require("../tokenizer").Tokenizer; +var TextHighlightRules = require("./text_highlight_rules").TextHighlightRules; +var CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour; +var unicode = require("../unicode"); +var lang = require("../lib/lang"); +var TokenIterator = require("../token_iterator").TokenIterator; +var Range = require("../range").Range; + +var Mode = function() { + this.HighlightRules = TextHighlightRules; +}; + +(function() { + this.$defaultBehaviour = new CstyleBehaviour(); + + this.tokenRe = new RegExp("^[" + unicode.wordChars + "\\$_]+", "g"); + + this.nonTokenRe = new RegExp("^(?:[^" + unicode.wordChars + "\\$_]|\\s])+", "g"); + + this.getTokenizer = function() { + if (!this.$tokenizer) { + this.$highlightRules = this.$highlightRules || new this.HighlightRules(this.$highlightRuleConfig); + this.$tokenizer = new Tokenizer(this.$highlightRules.getRules()); + } + return this.$tokenizer; + }; + + this.lineCommentStart = ""; + this.blockComment = ""; + + this.toggleCommentLines = function(state, session, startRow, endRow) { + var doc = session.doc; + + var ignoreBlankLines = true; + var shouldRemove = true; + var minIndent = Infinity; + var tabSize = session.getTabSize(); + var insertAtTabStop = false; + + if (!this.lineCommentStart) { + if (!this.blockComment) + return false; + var lineCommentStart = this.blockComment.start; + var lineCommentEnd = this.blockComment.end; + var regexpStart = new RegExp("^(\\s*)(?:" + lang.escapeRegExp(lineCommentStart) + ")"); + var regexpEnd = new RegExp("(?:" + lang.escapeRegExp(lineCommentEnd) + ")\\s*$"); + + var comment = function(line, i) { + if (testRemove(line, i)) + return; + if (!ignoreBlankLines || /\S/.test(line)) { + doc.insertInLine({row: i, column: line.length}, lineCommentEnd); + doc.insertInLine({row: i, column: minIndent}, lineCommentStart); + } + }; + + var uncomment = function(line, i) { + var m; + if (m = line.match(regexpEnd)) + doc.removeInLine(i, line.length - m[0].length, line.length); + if (m = line.match(regexpStart)) + doc.removeInLine(i, m[1].length, m[0].length); + }; + + var testRemove = function(line, row) { + if (regexpStart.test(line)) + return true; + var tokens = session.getTokens(row); + for (var i = 0; i < tokens.length; i++) { + if (tokens[i].type === "comment") + return true; + } + }; + } else { + if (Array.isArray(this.lineCommentStart)) { + var regexpStart = this.lineCommentStart.map(lang.escapeRegExp).join("|"); + var lineCommentStart = this.lineCommentStart[0]; + } else { + var regexpStart = lang.escapeRegExp(this.lineCommentStart); + var lineCommentStart = this.lineCommentStart; + } + regexpStart = new RegExp("^(\\s*)(?:" + regexpStart + ") ?"); + + insertAtTabStop = session.getUseSoftTabs(); + + var uncomment = function(line, i) { + var m = line.match(regexpStart); + if (!m) return; + var start = m[1].length, end = m[0].length; + if (!shouldInsertSpace(line, start, end) && m[0][end - 1] == " ") + end--; + doc.removeInLine(i, start, end); + }; + var commentWithSpace = lineCommentStart + " "; + var comment = function(line, i) { + if (!ignoreBlankLines || /\S/.test(line)) { + if (shouldInsertSpace(line, minIndent, minIndent)) + doc.insertInLine({row: i, column: minIndent}, commentWithSpace); + else + doc.insertInLine({row: i, column: minIndent}, lineCommentStart); + } + }; + var testRemove = function(line, i) { + return regexpStart.test(line); + }; + + var shouldInsertSpace = function(line, before, after) { + var spaces = 0; + while (before-- && line.charAt(before) == " ") + spaces++; + if (spaces % tabSize != 0) + return false; + var spaces = 0; + while (line.charAt(after++) == " ") + spaces++; + if (tabSize > 2) + return spaces % tabSize != tabSize - 1; + else + return spaces % tabSize == 0; + }; + } + + function iter(fun) { + for (var i = startRow; i <= endRow; i++) + fun(doc.getLine(i), i); + } + + + var minEmptyLength = Infinity; + iter(function(line, i) { + var indent = line.search(/\S/); + if (indent !== -1) { + if (indent < minIndent) + minIndent = indent; + if (shouldRemove && !testRemove(line, i)) + shouldRemove = false; + } else if (minEmptyLength > line.length) { + minEmptyLength = line.length; + } + }); + + if (minIndent == Infinity) { + minIndent = minEmptyLength; + ignoreBlankLines = false; + shouldRemove = false; + } + + if (insertAtTabStop && minIndent % tabSize != 0) + minIndent = Math.floor(minIndent / tabSize) * tabSize; + + iter(shouldRemove ? uncomment : comment); + }; + + this.toggleBlockComment = function(state, session, range, cursor) { + var comment = this.blockComment; + if (!comment) + return; + if (!comment.start && comment[0]) + comment = comment[0]; + + var iterator = new TokenIterator(session, cursor.row, cursor.column); + var token = iterator.getCurrentToken(); + + var sel = session.selection; + var initialRange = session.selection.toOrientedRange(); + var startRow, colDiff; + + if (token && /comment/.test(token.type)) { + var startRange, endRange; + while (token && /comment/.test(token.type)) { + var i = token.value.indexOf(comment.start); + if (i != -1) { + var row = iterator.getCurrentTokenRow(); + var column = iterator.getCurrentTokenColumn() + i; + startRange = new Range(row, column, row, column + comment.start.length); + break; + } + token = iterator.stepBackward(); + } + + var iterator = new TokenIterator(session, cursor.row, cursor.column); + var token = iterator.getCurrentToken(); + while (token && /comment/.test(token.type)) { + var i = token.value.indexOf(comment.end); + if (i != -1) { + var row = iterator.getCurrentTokenRow(); + var column = iterator.getCurrentTokenColumn() + i; + endRange = new Range(row, column, row, column + comment.end.length); + break; + } + token = iterator.stepForward(); + } + if (endRange) + session.remove(endRange); + if (startRange) { + session.remove(startRange); + startRow = startRange.start.row; + colDiff = -comment.start.length; + } + } else { + colDiff = comment.start.length; + startRow = range.start.row; + session.insert(range.end, comment.end); + session.insert(range.start, comment.start); + } + if (initialRange.start.row == startRow) + initialRange.start.column += colDiff; + if (initialRange.end.row == startRow) + initialRange.end.column += colDiff; + session.selection.fromOrientedRange(initialRange); + }; + + this.getNextLineIndent = function(state, line, tab) { + return this.$getIndent(line); + }; + + this.checkOutdent = function(state, line, input) { + return false; + }; + + this.autoOutdent = function(state, doc, row) { + }; + + this.$getIndent = function(line) { + return line.match(/^\s*/)[0]; + }; + + this.createWorker = function(session) { + return null; + }; + + this.createModeDelegates = function (mapping) { + this.$embeds = []; + this.$modes = {}; + for (var i in mapping) { + if (mapping[i]) { + var Mode = mapping[i]; + var id = Mode.prototype.$id; + var mode = config.$modes[id]; + if (!mode) + config.$modes[id] = mode = new Mode(); + if (!config.$modes[i]) + config.$modes[i] = mode; + this.$embeds.push(i); + this.$modes[i] = mode; + } + } + + var delegations = ["toggleBlockComment", "toggleCommentLines", "getNextLineIndent", + "checkOutdent", "autoOutdent", "transformAction", "getCompletions"]; + + for (var i = 0; i < delegations.length; i++) { + (function(scope) { + var functionName = delegations[i]; + var defaultHandler = scope[functionName]; + scope[delegations[i]] = function() { + return this.$delegator(functionName, arguments, defaultHandler); + }; + }(this)); + } + }; + + this.$delegator = function(method, args, defaultHandler) { + var state = args[0] || "start"; + if (typeof state != "string") { + if (Array.isArray(state[2])) { + var language = state[2][state[2].length - 1]; + var mode = this.$modes[language]; + if (mode) + return mode[method].apply(mode, [state[1]].concat([].slice.call(args, 1))); + } + state = state[0] || "start"; + } + + for (var i = 0; i < this.$embeds.length; i++) { + if (!this.$modes[this.$embeds[i]]) continue; + + var split = state.split(this.$embeds[i]); + if (!split[0] && split[1]) { + args[0] = split[1]; + var mode = this.$modes[this.$embeds[i]]; + return mode[method].apply(mode, args); + } + } + var ret = defaultHandler.apply(this, args); + return defaultHandler ? ret : undefined; + }; + + this.transformAction = function(state, action, editor, session, param) { + if (this.$behaviour) { + var behaviours = this.$behaviour.getBehaviours(); + for (var key in behaviours) { + if (behaviours[key][action]) { + var ret = behaviours[key][action].apply(this, arguments); + if (ret) { + return ret; + } + } + } + } + }; + + this.getKeywords = function(append) { + if (!this.completionKeywords) { + var rules = this.$tokenizer.rules; + var completionKeywords = []; + for (var rule in rules) { + var ruleItr = rules[rule]; + for (var r = 0, l = ruleItr.length; r < l; r++) { + if (typeof ruleItr[r].token === "string") { + if (/keyword|support|storage/.test(ruleItr[r].token)) + completionKeywords.push(ruleItr[r].regex); + } + else if (typeof ruleItr[r].token === "object") { + for (var a = 0, aLength = ruleItr[r].token.length; a < aLength; a++) { + if (/keyword|support|storage/.test(ruleItr[r].token[a])) { + var rule = ruleItr[r].regex.match(/\(.+?\)/g)[a]; + completionKeywords.push(rule.substr(1, rule.length - 2)); + } + } + } + } + } + this.completionKeywords = completionKeywords; + } + if (!append) + return this.$keywordList; + return completionKeywords.concat(this.$keywordList || []); + }; + + this.$createKeywordList = function() { + if (!this.$highlightRules) + this.getTokenizer(); + return this.$keywordList = this.$highlightRules.$keywordList || []; + }; + + this.getCompletions = function(state, session, pos, prefix) { + var keywords = this.$keywordList || this.$createKeywordList(); + return keywords.map(function(word) { + return { + name: word, + value: word, + score: 0, + meta: "keyword" + }; + }); + }; + + this.$id = "ace/mode/text"; +}).call(Mode.prototype); + +exports.Mode = Mode; +}); + +ace.define("ace/apply_delta",["require","exports","module"], function(require, exports, module) { +"use strict"; + +function throwDeltaError(delta, errorText){ + console.log("Invalid Delta:", delta); + throw "Invalid Delta: " + errorText; +} + +function positionInDocument(docLines, position) { + return position.row >= 0 && position.row < docLines.length && + position.column >= 0 && position.column <= docLines[position.row].length; +} + +function validateDelta(docLines, delta) { + if (delta.action != "insert" && delta.action != "remove") + throwDeltaError(delta, "delta.action must be 'insert' or 'remove'"); + if (!(delta.lines instanceof Array)) + throwDeltaError(delta, "delta.lines must be an Array"); + if (!delta.start || !delta.end) + throwDeltaError(delta, "delta.start/end must be an present"); + var start = delta.start; + if (!positionInDocument(docLines, delta.start)) + throwDeltaError(delta, "delta.start must be contained in document"); + var end = delta.end; + if (delta.action == "remove" && !positionInDocument(docLines, end)) + throwDeltaError(delta, "delta.end must contained in document for 'remove' actions"); + var numRangeRows = end.row - start.row; + var numRangeLastLineChars = (end.column - (numRangeRows == 0 ? start.column : 0)); + if (numRangeRows != delta.lines.length - 1 || delta.lines[numRangeRows].length != numRangeLastLineChars) + throwDeltaError(delta, "delta.range must match delta lines"); +} + +exports.applyDelta = function(docLines, delta, doNotValidate) { + + var row = delta.start.row; + var startColumn = delta.start.column; + var line = docLines[row] || ""; + switch (delta.action) { + case "insert": + var lines = delta.lines; + if (lines.length === 1) { + docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn); + } else { + var args = [row, 1].concat(delta.lines); + docLines.splice.apply(docLines, args); + docLines[row] = line.substring(0, startColumn) + docLines[row]; + docLines[row + delta.lines.length - 1] += line.substring(startColumn); + } + break; + case "remove": + var endColumn = delta.end.column; + var endRow = delta.end.row; + if (row === endRow) { + docLines[row] = line.substring(0, startColumn) + line.substring(endColumn); + } else { + docLines.splice( + row, endRow - row + 1, + line.substring(0, startColumn) + docLines[endRow].substring(endColumn) + ); + } + break; + } +}; +}); + +ace.define("ace/anchor",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; + +var Anchor = exports.Anchor = function(doc, row, column) { + this.$onChange = this.onChange.bind(this); + this.attach(doc); + + if (typeof column == "undefined") + this.setPosition(row.row, row.column); + else + this.setPosition(row, column); +}; + +(function() { + + oop.implement(this, EventEmitter); + this.getPosition = function() { + return this.$clipPositionToDocument(this.row, this.column); + }; + this.getDocument = function() { + return this.document; + }; + this.$insertRight = false; + this.onChange = function(delta) { + if (delta.start.row == delta.end.row && delta.start.row != this.row) + return; + + if (delta.start.row > this.row) + return; + + var point = $getTransformedPoint(delta, {row: this.row, column: this.column}, this.$insertRight); + this.setPosition(point.row, point.column, true); + }; + + function $pointsInOrder(point1, point2, equalPointsInOrder) { + var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column; + return (point1.row < point2.row) || (point1.row == point2.row && bColIsAfter); + } + + function $getTransformedPoint(delta, point, moveIfEqual) { + var deltaIsInsert = delta.action == "insert"; + var deltaRowShift = (deltaIsInsert ? 1 : -1) * (delta.end.row - delta.start.row); + var deltaColShift = (deltaIsInsert ? 1 : -1) * (delta.end.column - delta.start.column); + var deltaStart = delta.start; + var deltaEnd = deltaIsInsert ? deltaStart : delta.end; // Collapse insert range. + if ($pointsInOrder(point, deltaStart, moveIfEqual)) { + return { + row: point.row, + column: point.column + }; + } + if ($pointsInOrder(deltaEnd, point, !moveIfEqual)) { + return { + row: point.row + deltaRowShift, + column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0) + }; + } + + return { + row: deltaStart.row, + column: deltaStart.column + }; + } + this.setPosition = function(row, column, noClip) { + var pos; + if (noClip) { + pos = { + row: row, + column: column + }; + } else { + pos = this.$clipPositionToDocument(row, column); + } + + if (this.row == pos.row && this.column == pos.column) + return; + + var old = { + row: this.row, + column: this.column + }; + + this.row = pos.row; + this.column = pos.column; + this._signal("change", { + old: old, + value: pos + }); + }; + this.detach = function() { + this.document.off("change", this.$onChange); + }; + this.attach = function(doc) { + this.document = doc || this.document; + this.document.on("change", this.$onChange); + }; + this.$clipPositionToDocument = function(row, column) { + var pos = {}; + + if (row >= this.document.getLength()) { + pos.row = Math.max(0, this.document.getLength() - 1); + pos.column = this.document.getLine(pos.row).length; + } + else if (row < 0) { + pos.row = 0; + pos.column = 0; + } + else { + pos.row = row; + pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column)); + } + + if (column < 0) + pos.column = 0; + + return pos; + }; + +}).call(Anchor.prototype); + +}); + +ace.define("ace/document",["require","exports","module","ace/lib/oop","ace/apply_delta","ace/lib/event_emitter","ace/range","ace/anchor"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var applyDelta = require("./apply_delta").applyDelta; +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var Range = require("./range").Range; +var Anchor = require("./anchor").Anchor; + +var Document = function(textOrLines) { + this.$lines = [""]; + if (textOrLines.length === 0) { + this.$lines = [""]; + } else if (Array.isArray(textOrLines)) { + this.insertMergedLines({row: 0, column: 0}, textOrLines); + } else { + this.insert({row: 0, column:0}, textOrLines); + } +}; + +(function() { + + oop.implement(this, EventEmitter); + this.setValue = function(text) { + var len = this.getLength() - 1; + this.remove(new Range(0, 0, len, this.getLine(len).length)); + this.insert({row: 0, column: 0}, text); + }; + this.getValue = function() { + return this.getAllLines().join(this.getNewLineCharacter()); + }; + this.createAnchor = function(row, column) { + return new Anchor(this, row, column); + }; + if ("aaa".split(/a/).length === 0) { + this.$split = function(text) { + return text.replace(/\r\n|\r/g, "\n").split("\n"); + }; + } else { + this.$split = function(text) { + return text.split(/\r\n|\r|\n/); + }; + } + + + this.$detectNewLine = function(text) { + var match = text.match(/^.*?(\r\n|\r|\n)/m); + this.$autoNewLine = match ? match[1] : "\n"; + this._signal("changeNewLineMode"); + }; + this.getNewLineCharacter = function() { + switch (this.$newLineMode) { + case "windows": + return "\r\n"; + case "unix": + return "\n"; + default: + return this.$autoNewLine || "\n"; + } + }; + + this.$autoNewLine = ""; + this.$newLineMode = "auto"; + this.setNewLineMode = function(newLineMode) { + if (this.$newLineMode === newLineMode) + return; + + this.$newLineMode = newLineMode; + this._signal("changeNewLineMode"); + }; + this.getNewLineMode = function() { + return this.$newLineMode; + }; + this.isNewLine = function(text) { + return (text == "\r\n" || text == "\r" || text == "\n"); + }; + this.getLine = function(row) { + return this.$lines[row] || ""; + }; + this.getLines = function(firstRow, lastRow) { + return this.$lines.slice(firstRow, lastRow + 1); + }; + this.getAllLines = function() { + return this.getLines(0, this.getLength()); + }; + this.getLength = function() { + return this.$lines.length; + }; + this.getTextRange = function(range) { + return this.getLinesForRange(range).join(this.getNewLineCharacter()); + }; + this.getLinesForRange = function(range) { + var lines; + if (range.start.row === range.end.row) { + lines = [this.getLine(range.start.row).substring(range.start.column, range.end.column)]; + } else { + lines = this.getLines(range.start.row, range.end.row); + lines[0] = (lines[0] || "").substring(range.start.column); + var l = lines.length - 1; + if (range.end.row - range.start.row == l) + lines[l] = lines[l].substring(0, range.end.column); + } + return lines; + }; + this.insertLines = function(row, lines) { + console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead."); + return this.insertFullLines(row, lines); + }; + this.removeLines = function(firstRow, lastRow) { + console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead."); + return this.removeFullLines(firstRow, lastRow); + }; + this.insertNewLine = function(position) { + console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead."); + return this.insertMergedLines(position, ["", ""]); + }; + this.insert = function(position, text) { + if (this.getLength() <= 1) + this.$detectNewLine(text); + + return this.insertMergedLines(position, this.$split(text)); + }; + this.insertInLine = function(position, text) { + var start = this.clippedPos(position.row, position.column); + var end = this.pos(position.row, position.column + text.length); + + this.applyDelta({ + start: start, + end: end, + action: "insert", + lines: [text] + }, true); + + return this.clonePos(end); + }; + + this.clippedPos = function(row, column) { + var length = this.getLength(); + if (row === undefined) { + row = length; + } else if (row < 0) { + row = 0; + } else if (row >= length) { + row = length - 1; + column = undefined; + } + var line = this.getLine(row); + if (column == undefined) + column = line.length; + column = Math.min(Math.max(column, 0), line.length); + return {row: row, column: column}; + }; + + this.clonePos = function(pos) { + return {row: pos.row, column: pos.column}; + }; + + this.pos = function(row, column) { + return {row: row, column: column}; + }; + + this.$clipPosition = function(position) { + var length = this.getLength(); + if (position.row >= length) { + position.row = Math.max(0, length - 1); + position.column = this.getLine(length - 1).length; + } else { + position.row = Math.max(0, position.row); + position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length); + } + return position; + }; + this.insertFullLines = function(row, lines) { + row = Math.min(Math.max(row, 0), this.getLength()); + var column = 0; + if (row < this.getLength()) { + lines = lines.concat([""]); + column = 0; + } else { + lines = [""].concat(lines); + row--; + column = this.$lines[row].length; + } + this.insertMergedLines({row: row, column: column}, lines); + }; + this.insertMergedLines = function(position, lines) { + var start = this.clippedPos(position.row, position.column); + var end = { + row: start.row + lines.length - 1, + column: (lines.length == 1 ? start.column : 0) + lines[lines.length - 1].length + }; + + this.applyDelta({ + start: start, + end: end, + action: "insert", + lines: lines + }); + + return this.clonePos(end); + }; + this.remove = function(range) { + var start = this.clippedPos(range.start.row, range.start.column); + var end = this.clippedPos(range.end.row, range.end.column); + this.applyDelta({ + start: start, + end: end, + action: "remove", + lines: this.getLinesForRange({start: start, end: end}) + }); + return this.clonePos(start); + }; + this.removeInLine = function(row, startColumn, endColumn) { + var start = this.clippedPos(row, startColumn); + var end = this.clippedPos(row, endColumn); + + this.applyDelta({ + start: start, + end: end, + action: "remove", + lines: this.getLinesForRange({start: start, end: end}) + }, true); + + return this.clonePos(start); + }; + this.removeFullLines = function(firstRow, lastRow) { + firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1); + lastRow = Math.min(Math.max(0, lastRow ), this.getLength() - 1); + var deleteFirstNewLine = lastRow == this.getLength() - 1 && firstRow > 0; + var deleteLastNewLine = lastRow < this.getLength() - 1; + var startRow = ( deleteFirstNewLine ? firstRow - 1 : firstRow ); + var startCol = ( deleteFirstNewLine ? this.getLine(startRow).length : 0 ); + var endRow = ( deleteLastNewLine ? lastRow + 1 : lastRow ); + var endCol = ( deleteLastNewLine ? 0 : this.getLine(endRow).length ); + var range = new Range(startRow, startCol, endRow, endCol); + var deletedLines = this.$lines.slice(firstRow, lastRow + 1); + + this.applyDelta({ + start: range.start, + end: range.end, + action: "remove", + lines: this.getLinesForRange(range) + }); + return deletedLines; + }; + this.removeNewLine = function(row) { + if (row < this.getLength() - 1 && row >= 0) { + this.applyDelta({ + start: this.pos(row, this.getLine(row).length), + end: this.pos(row + 1, 0), + action: "remove", + lines: ["", ""] + }); + } + }; + this.replace = function(range, text) { + if (!(range instanceof Range)) + range = Range.fromPoints(range.start, range.end); + if (text.length === 0 && range.isEmpty()) + return range.start; + if (text == this.getTextRange(range)) + return range.end; + + this.remove(range); + var end; + if (text) { + end = this.insert(range.start, text); + } + else { + end = range.start; + } + + return end; + }; + this.applyDeltas = function(deltas) { + for (var i=0; i=0; i--) { + this.revertDelta(deltas[i]); + } + }; + this.applyDelta = function(delta, doNotValidate) { + var isInsert = delta.action == "insert"; + if (isInsert ? delta.lines.length <= 1 && !delta.lines[0] + : !Range.comparePoints(delta.start, delta.end)) { + return; + } + + if (isInsert && delta.lines.length > 20000) { + this.$splitAndapplyLargeDelta(delta, 20000); + } + else { + applyDelta(this.$lines, delta, doNotValidate); + this._signal("change", delta); + } + }; + + this.$safeApplyDelta = function(delta) { + var docLength = this.$lines.length; + if ( + delta.action == "remove" && delta.start.row < docLength && delta.end.row < docLength + || delta.action == "insert" && delta.start.row <= docLength + ) { + this.applyDelta(delta); + } + }; + + this.$splitAndapplyLargeDelta = function(delta, MAX) { + var lines = delta.lines; + var l = lines.length - MAX + 1; + var row = delta.start.row; + var column = delta.start.column; + for (var from = 0, to = 0; from < l; from = to) { + to += MAX - 1; + var chunk = lines.slice(from, to); + chunk.push(""); + this.applyDelta({ + start: this.pos(row + from, column), + end: this.pos(row + to, column = 0), + action: delta.action, + lines: chunk + }, true); + } + delta.lines = lines.slice(from); + delta.start.row = row + from; + delta.start.column = column; + this.applyDelta(delta, true); + }; + this.revertDelta = function(delta) { + this.$safeApplyDelta({ + start: this.clonePos(delta.start), + end: this.clonePos(delta.end), + action: (delta.action == "insert" ? "remove" : "insert"), + lines: delta.lines.slice() + }); + }; + this.indexToPosition = function(index, startRow) { + var lines = this.$lines || this.getAllLines(); + var newlineLength = this.getNewLineCharacter().length; + for (var i = startRow || 0, l = lines.length; i < l; i++) { + index -= lines[i].length + newlineLength; + if (index < 0) + return {row: i, column: index + lines[i].length + newlineLength}; + } + return {row: l-1, column: index + lines[l-1].length + newlineLength}; + }; + this.positionToIndex = function(pos, startRow) { + var lines = this.$lines || this.getAllLines(); + var newlineLength = this.getNewLineCharacter().length; + var index = 0; + var row = Math.min(pos.row, lines.length); + for (var i = startRow || 0; i < row; ++i) + index += lines[i].length + newlineLength; + + return index + pos.column; + }; + +}).call(Document.prototype); + +exports.Document = Document; +}); + +ace.define("ace/background_tokenizer",["require","exports","module","ace/lib/oop","ace/lib/event_emitter"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; + +var BackgroundTokenizer = function(tokenizer, editor) { + this.running = false; + this.lines = []; + this.states = []; + this.currentLine = 0; + this.tokenizer = tokenizer; + + var self = this; + + this.$worker = function() { + if (!self.running) { return; } + + var workerStart = new Date(); + var currentLine = self.currentLine; + var endLine = -1; + var doc = self.doc; + + var startLine = currentLine; + while (self.lines[currentLine]) + currentLine++; + + var len = doc.getLength(); + var processedLines = 0; + self.running = false; + while (currentLine < len) { + self.$tokenizeRow(currentLine); + endLine = currentLine; + do { + currentLine++; + } while (self.lines[currentLine]); + processedLines ++; + if ((processedLines % 5 === 0) && (new Date() - workerStart) > 20) { + self.running = setTimeout(self.$worker, 20); + break; + } + } + self.currentLine = currentLine; + + if (endLine == -1) + endLine = currentLine; + + if (startLine <= endLine) + self.fireUpdateEvent(startLine, endLine); + }; +}; + +(function(){ + + oop.implement(this, EventEmitter); + this.setTokenizer = function(tokenizer) { + this.tokenizer = tokenizer; + this.lines = []; + this.states = []; + + this.start(0); + }; + this.setDocument = function(doc) { + this.doc = doc; + this.lines = []; + this.states = []; + + this.stop(); + }; + this.fireUpdateEvent = function(firstRow, lastRow) { + var data = { + first: firstRow, + last: lastRow + }; + this._signal("update", {data: data}); + }; + this.start = function(startRow) { + this.currentLine = Math.min(startRow || 0, this.currentLine, this.doc.getLength()); + this.lines.splice(this.currentLine, this.lines.length); + this.states.splice(this.currentLine, this.states.length); + + this.stop(); + this.running = setTimeout(this.$worker, 700); + }; + + this.scheduleStart = function() { + if (!this.running) + this.running = setTimeout(this.$worker, 700); + }; + + this.$updateOnChange = function(delta) { + var startRow = delta.start.row; + var len = delta.end.row - startRow; + + if (len === 0) { + this.lines[startRow] = null; + } else if (delta.action == "remove") { + this.lines.splice(startRow, len + 1, null); + this.states.splice(startRow, len + 1, null); + } else { + var args = Array(len + 1); + args.unshift(startRow, 1); + this.lines.splice.apply(this.lines, args); + this.states.splice.apply(this.states, args); + } + + this.currentLine = Math.min(startRow, this.currentLine, this.doc.getLength()); + + this.stop(); + }; + this.stop = function() { + if (this.running) + clearTimeout(this.running); + this.running = false; + }; + this.getTokens = function(row) { + return this.lines[row] || this.$tokenizeRow(row); + }; + this.getState = function(row) { + if (this.currentLine == row) + this.$tokenizeRow(row); + return this.states[row] || "start"; + }; + + this.$tokenizeRow = function(row) { + var line = this.doc.getLine(row); + var state = this.states[row - 1]; + + var data = this.tokenizer.getLineTokens(line, state, row); + + if (this.states[row] + "" !== data.state + "") { + this.states[row] = data.state; + this.lines[row + 1] = null; + if (this.currentLine > row + 1) + this.currentLine = row + 1; + } else if (this.currentLine == row) { + this.currentLine = row + 1; + } + + return this.lines[row] = data.tokens; + }; + +}).call(BackgroundTokenizer.prototype); + +exports.BackgroundTokenizer = BackgroundTokenizer; +}); + +ace.define("ace/search_highlight",["require","exports","module","ace/lib/lang","ace/lib/oop","ace/range"], function(require, exports, module) { +"use strict"; + +var lang = require("./lib/lang"); +var oop = require("./lib/oop"); +var Range = require("./range").Range; + +var SearchHighlight = function(regExp, clazz, type) { + this.setRegexp(regExp); + this.clazz = clazz; + this.type = type || "text"; +}; + +(function() { + this.MAX_RANGES = 500; + + this.setRegexp = function(regExp) { + if (this.regExp+"" == regExp+"") + return; + this.regExp = regExp; + this.cache = []; + }; + + this.update = function(html, markerLayer, session, config) { + if (!this.regExp) + return; + var start = config.firstRow, end = config.lastRow; + + for (var i = start; i <= end; i++) { + var ranges = this.cache[i]; + if (ranges == null) { + ranges = lang.getMatchOffsets(session.getLine(i), this.regExp); + if (ranges.length > this.MAX_RANGES) + ranges = ranges.slice(0, this.MAX_RANGES); + ranges = ranges.map(function(match) { + return new Range(i, match.offset, i, match.offset + match.length); + }); + this.cache[i] = ranges.length ? ranges : ""; + } + + for (var j = ranges.length; j --; ) { + markerLayer.drawSingleLineMarker( + html, ranges[j].toScreenRange(session), this.clazz, config); + } + } + }; + +}).call(SearchHighlight.prototype); + +exports.SearchHighlight = SearchHighlight; +}); + +ace.define("ace/edit_session/fold_line",["require","exports","module","ace/range"], function(require, exports, module) { +"use strict"; + +var Range = require("../range").Range; +function FoldLine(foldData, folds) { + this.foldData = foldData; + if (Array.isArray(folds)) { + this.folds = folds; + } else { + folds = this.folds = [ folds ]; + } + + var last = folds[folds.length - 1]; + this.range = new Range(folds[0].start.row, folds[0].start.column, + last.end.row, last.end.column); + this.start = this.range.start; + this.end = this.range.end; + + this.folds.forEach(function(fold) { + fold.setFoldLine(this); + }, this); +} + +(function() { + this.shiftRow = function(shift) { + this.start.row += shift; + this.end.row += shift; + this.folds.forEach(function(fold) { + fold.start.row += shift; + fold.end.row += shift; + }); + }; + + this.addFold = function(fold) { + if (fold.sameRow) { + if (fold.start.row < this.startRow || fold.endRow > this.endRow) { + throw new Error("Can't add a fold to this FoldLine as it has no connection"); + } + this.folds.push(fold); + this.folds.sort(function(a, b) { + return -a.range.compareEnd(b.start.row, b.start.column); + }); + if (this.range.compareEnd(fold.start.row, fold.start.column) > 0) { + this.end.row = fold.end.row; + this.end.column = fold.end.column; + } else if (this.range.compareStart(fold.end.row, fold.end.column) < 0) { + this.start.row = fold.start.row; + this.start.column = fold.start.column; + } + } else if (fold.start.row == this.end.row) { + this.folds.push(fold); + this.end.row = fold.end.row; + this.end.column = fold.end.column; + } else if (fold.end.row == this.start.row) { + this.folds.unshift(fold); + this.start.row = fold.start.row; + this.start.column = fold.start.column; + } else { + throw new Error("Trying to add fold to FoldRow that doesn't have a matching row"); + } + fold.foldLine = this; + }; + + this.containsRow = function(row) { + return row >= this.start.row && row <= this.end.row; + }; + + this.walk = function(callback, endRow, endColumn) { + var lastEnd = 0, + folds = this.folds, + fold, + cmp, stop, isNewRow = true; + + if (endRow == null) { + endRow = this.end.row; + endColumn = this.end.column; + } + + for (var i = 0; i < folds.length; i++) { + fold = folds[i]; + + cmp = fold.range.compareStart(endRow, endColumn); + if (cmp == -1) { + callback(null, endRow, endColumn, lastEnd, isNewRow); + return; + } + + stop = callback(null, fold.start.row, fold.start.column, lastEnd, isNewRow); + stop = !stop && callback(fold.placeholder, fold.start.row, fold.start.column, lastEnd); + if (stop || cmp === 0) { + return; + } + isNewRow = !fold.sameRow; + lastEnd = fold.end.column; + } + callback(null, endRow, endColumn, lastEnd, isNewRow); + }; + + this.getNextFoldTo = function(row, column) { + var fold, cmp; + for (var i = 0; i < this.folds.length; i++) { + fold = this.folds[i]; + cmp = fold.range.compareEnd(row, column); + if (cmp == -1) { + return { + fold: fold, + kind: "after" + }; + } else if (cmp === 0) { + return { + fold: fold, + kind: "inside" + }; + } + } + return null; + }; + + this.addRemoveChars = function(row, column, len) { + var ret = this.getNextFoldTo(row, column), + fold, folds; + if (ret) { + fold = ret.fold; + if (ret.kind == "inside" + && fold.start.column != column + && fold.start.row != row) + { + window.console && window.console.log(row, column, fold); + } else if (fold.start.row == row) { + folds = this.folds; + var i = folds.indexOf(fold); + if (i === 0) { + this.start.column += len; + } + for (i; i < folds.length; i++) { + fold = folds[i]; + fold.start.column += len; + if (!fold.sameRow) { + return; + } + fold.end.column += len; + } + this.end.column += len; + } + } + }; + + this.split = function(row, column) { + var pos = this.getNextFoldTo(row, column); + + if (!pos || pos.kind == "inside") + return null; + + var fold = pos.fold; + var folds = this.folds; + var foldData = this.foldData; + + var i = folds.indexOf(fold); + var foldBefore = folds[i - 1]; + this.end.row = foldBefore.end.row; + this.end.column = foldBefore.end.column; + folds = folds.splice(i, folds.length - i); + + var newFoldLine = new FoldLine(foldData, folds); + foldData.splice(foldData.indexOf(this) + 1, 0, newFoldLine); + return newFoldLine; + }; + + this.merge = function(foldLineNext) { + var folds = foldLineNext.folds; + for (var i = 0; i < folds.length; i++) { + this.addFold(folds[i]); + } + var foldData = this.foldData; + foldData.splice(foldData.indexOf(foldLineNext), 1); + }; + + this.toString = function() { + var ret = [this.range.toString() + ": [" ]; + + this.folds.forEach(function(fold) { + ret.push(" " + fold.toString()); + }); + ret.push("]"); + return ret.join("\n"); + }; + + this.idxToPosition = function(idx) { + var lastFoldEndColumn = 0; + + for (var i = 0; i < this.folds.length; i++) { + var fold = this.folds[i]; + + idx -= fold.start.column - lastFoldEndColumn; + if (idx < 0) { + return { + row: fold.start.row, + column: fold.start.column + idx + }; + } + + idx -= fold.placeholder.length; + if (idx < 0) { + return fold.start; + } + + lastFoldEndColumn = fold.end.column; + } + + return { + row: this.end.row, + column: this.end.column + idx + }; + }; +}).call(FoldLine.prototype); + +exports.FoldLine = FoldLine; +}); + +ace.define("ace/range_list",["require","exports","module","ace/range"], function(require, exports, module) { +"use strict"; +var Range = require("./range").Range; +var comparePoints = Range.comparePoints; + +var RangeList = function() { + this.ranges = []; + this.$bias = 1; +}; + +(function() { + this.comparePoints = comparePoints; + + this.pointIndex = function(pos, excludeEdges, startIndex) { + var list = this.ranges; + + for (var i = startIndex || 0; i < list.length; i++) { + var range = list[i]; + var cmpEnd = comparePoints(pos, range.end); + if (cmpEnd > 0) + continue; + var cmpStart = comparePoints(pos, range.start); + if (cmpEnd === 0) + return excludeEdges && cmpStart !== 0 ? -i-2 : i; + if (cmpStart > 0 || (cmpStart === 0 && !excludeEdges)) + return i; + + return -i-1; + } + return -i - 1; + }; + + this.add = function(range) { + var excludeEdges = !range.isEmpty(); + var startIndex = this.pointIndex(range.start, excludeEdges); + if (startIndex < 0) + startIndex = -startIndex - 1; + + var endIndex = this.pointIndex(range.end, excludeEdges, startIndex); + + if (endIndex < 0) + endIndex = -endIndex - 1; + else + endIndex++; + return this.ranges.splice(startIndex, endIndex - startIndex, range); + }; + + this.addList = function(list) { + var removed = []; + for (var i = list.length; i--; ) { + removed.push.apply(removed, this.add(list[i])); + } + return removed; + }; + + this.substractPoint = function(pos) { + var i = this.pointIndex(pos); + + if (i >= 0) + return this.ranges.splice(i, 1); + }; + this.merge = function() { + var removed = []; + var list = this.ranges; + + list = list.sort(function(a, b) { + return comparePoints(a.start, b.start); + }); + + var next = list[0], range; + for (var i = 1; i < list.length; i++) { + range = next; + next = list[i]; + var cmp = comparePoints(range.end, next.start); + if (cmp < 0) + continue; + + if (cmp == 0 && !range.isEmpty() && !next.isEmpty()) + continue; + + if (comparePoints(range.end, next.end) < 0) { + range.end.row = next.end.row; + range.end.column = next.end.column; + } + + list.splice(i, 1); + removed.push(next); + next = range; + i--; + } + + this.ranges = list; + + return removed; + }; + + this.contains = function(row, column) { + return this.pointIndex({row: row, column: column}) >= 0; + }; + + this.containsPoint = function(pos) { + return this.pointIndex(pos) >= 0; + }; + + this.rangeAtPoint = function(pos) { + var i = this.pointIndex(pos); + if (i >= 0) + return this.ranges[i]; + }; + + + this.clipRows = function(startRow, endRow) { + var list = this.ranges; + if (list[0].start.row > endRow || list[list.length - 1].start.row < startRow) + return []; + + var startIndex = this.pointIndex({row: startRow, column: 0}); + if (startIndex < 0) + startIndex = -startIndex - 1; + var endIndex = this.pointIndex({row: endRow, column: 0}, startIndex); + if (endIndex < 0) + endIndex = -endIndex - 1; + + var clipped = []; + for (var i = startIndex; i < endIndex; i++) { + clipped.push(list[i]); + } + return clipped; + }; + + this.removeAll = function() { + return this.ranges.splice(0, this.ranges.length); + }; + + this.attach = function(session) { + if (this.session) + this.detach(); + + this.session = session; + this.onChange = this.$onChange.bind(this); + + this.session.on('change', this.onChange); + }; + + this.detach = function() { + if (!this.session) + return; + this.session.removeListener('change', this.onChange); + this.session = null; + }; + + this.$onChange = function(delta) { + var start = delta.start; + var end = delta.end; + var startRow = start.row; + var endRow = end.row; + var ranges = this.ranges; + for (var i = 0, n = ranges.length; i < n; i++) { + var r = ranges[i]; + if (r.end.row >= startRow) + break; + } + + if (delta.action == "insert") { + var lineDif = endRow - startRow; + var colDiff = -start.column + end.column; + for (; i < n; i++) { + var r = ranges[i]; + if (r.start.row > startRow) + break; + + if (r.start.row == startRow && r.start.column >= start.column) { + if (r.start.column == start.column && this.$bias <= 0) { + } else { + r.start.column += colDiff; + r.start.row += lineDif; + } + } + if (r.end.row == startRow && r.end.column >= start.column) { + if (r.end.column == start.column && this.$bias < 0) { + continue; + } + if (r.end.column == start.column && colDiff > 0 && i < n - 1) { + if (r.end.column > r.start.column && r.end.column == ranges[i+1].start.column) + r.end.column -= colDiff; + } + r.end.column += colDiff; + r.end.row += lineDif; + } + } + } else { + var lineDif = startRow - endRow; + var colDiff = start.column - end.column; + for (; i < n; i++) { + var r = ranges[i]; + + if (r.start.row > endRow) + break; + + if (r.end.row < endRow + && ( + startRow < r.end.row + || startRow == r.end.row && start.column < r.end.column + ) + ) { + r.end.row = startRow; + r.end.column = start.column; + } + else if (r.end.row == endRow) { + if (r.end.column <= end.column) { + if (lineDif || r.end.column > start.column) { + r.end.column = start.column; + r.end.row = start.row; + } + } + else { + r.end.column += colDiff; + r.end.row += lineDif; + } + } + else if (r.end.row > endRow) { + r.end.row += lineDif; + } + + if (r.start.row < endRow + && ( + startRow < r.start.row + || startRow == r.start.row && start.column < r.start.column + ) + ) { + r.start.row = startRow; + r.start.column = start.column; + } + else if (r.start.row == endRow) { + if (r.start.column <= end.column) { + if (lineDif || r.start.column > start.column) { + r.start.column = start.column; + r.start.row = start.row; + } + } + else { + r.start.column += colDiff; + r.start.row += lineDif; + } + } + else if (r.start.row > endRow) { + r.start.row += lineDif; + } + } + } + + if (lineDif != 0 && i < n) { + for (; i < n; i++) { + var r = ranges[i]; + r.start.row += lineDif; + r.end.row += lineDif; + } + } + }; + +}).call(RangeList.prototype); + +exports.RangeList = RangeList; +}); + +ace.define("ace/edit_session/fold",["require","exports","module","ace/range_list","ace/lib/oop"], function(require, exports, module) { +"use strict"; + +var RangeList = require("../range_list").RangeList; +var oop = require("../lib/oop"); +var Fold = exports.Fold = function(range, placeholder) { + this.foldLine = null; + this.placeholder = placeholder; + this.range = range; + this.start = range.start; + this.end = range.end; + + this.sameRow = range.start.row == range.end.row; + this.subFolds = this.ranges = []; +}; + +oop.inherits(Fold, RangeList); + +(function() { + + this.toString = function() { + return '"' + this.placeholder + '" ' + this.range.toString(); + }; + + this.setFoldLine = function(foldLine) { + this.foldLine = foldLine; + this.subFolds.forEach(function(fold) { + fold.setFoldLine(foldLine); + }); + }; + + this.clone = function() { + var range = this.range.clone(); + var fold = new Fold(range, this.placeholder); + this.subFolds.forEach(function(subFold) { + fold.subFolds.push(subFold.clone()); + }); + fold.collapseChildren = this.collapseChildren; + return fold; + }; + + this.addSubFold = function(fold) { + if (this.range.isEqual(fold)) + return; + consumeRange(fold, this.start); + + var row = fold.start.row, column = fold.start.column; + for (var i = 0, cmp = -1; i < this.subFolds.length; i++) { + cmp = this.subFolds[i].range.compare(row, column); + if (cmp != 1) + break; + } + var afterStart = this.subFolds[i]; + var firstConsumed = 0; + + if (cmp == 0) { + if (afterStart.range.containsRange(fold)) + return afterStart.addSubFold(fold); + else + firstConsumed = 1; + } + var row = fold.range.end.row, column = fold.range.end.column; + for (var j = i, cmp = -1; j < this.subFolds.length; j++) { + cmp = this.subFolds[j].range.compare(row, column); + if (cmp != 1) + break; + } + if (cmp == 0) j++; + var consumedFolds = this.subFolds.splice(i, j - i, fold); + var last = cmp == 0 ? consumedFolds.length - 1 : consumedFolds.length; + for (var k = firstConsumed; k < last; k++) { + fold.addSubFold(consumedFolds[k]); + } + fold.setFoldLine(this.foldLine); + + return fold; + }; + + this.restoreRange = function(range) { + return restoreRange(range, this.start); + }; + +}).call(Fold.prototype); + +function consumePoint(point, anchor) { + point.row -= anchor.row; + if (point.row == 0) + point.column -= anchor.column; +} +function consumeRange(range, anchor) { + consumePoint(range.start, anchor); + consumePoint(range.end, anchor); +} +function restorePoint(point, anchor) { + if (point.row == 0) + point.column += anchor.column; + point.row += anchor.row; +} +function restoreRange(range, anchor) { + restorePoint(range.start, anchor); + restorePoint(range.end, anchor); +} + +}); + +ace.define("ace/edit_session/folding",["require","exports","module","ace/range","ace/edit_session/fold_line","ace/edit_session/fold","ace/token_iterator"], function(require, exports, module) { +"use strict"; + +var Range = require("../range").Range; +var FoldLine = require("./fold_line").FoldLine; +var Fold = require("./fold").Fold; +var TokenIterator = require("../token_iterator").TokenIterator; + +function Folding() { + this.getFoldAt = function(row, column, side) { + var foldLine = this.getFoldLine(row); + if (!foldLine) + return null; + + var folds = foldLine.folds; + for (var i = 0; i < folds.length; i++) { + var range = folds[i].range; + if (range.contains(row, column)) { + if (side == 1 && range.isEnd(row, column) && !range.isEmpty()) { + continue; + } else if (side == -1 && range.isStart(row, column) && !range.isEmpty()) { + continue; + } + return folds[i]; + } + } + }; + this.getFoldsInRange = function(range) { + var start = range.start; + var end = range.end; + var foldLines = this.$foldData; + var foundFolds = []; + + start.column += 1; + end.column -= 1; + + for (var i = 0; i < foldLines.length; i++) { + var cmp = foldLines[i].range.compareRange(range); + if (cmp == 2) { + continue; + } + else if (cmp == -2) { + break; + } + + var folds = foldLines[i].folds; + for (var j = 0; j < folds.length; j++) { + var fold = folds[j]; + cmp = fold.range.compareRange(range); + if (cmp == -2) { + break; + } else if (cmp == 2) { + continue; + } else + if (cmp == 42) { + break; + } + foundFolds.push(fold); + } + } + start.column -= 1; + end.column += 1; + + return foundFolds; + }; + + this.getFoldsInRangeList = function(ranges) { + if (Array.isArray(ranges)) { + var folds = []; + ranges.forEach(function(range) { + folds = folds.concat(this.getFoldsInRange(range)); + }, this); + } else { + var folds = this.getFoldsInRange(ranges); + } + return folds; + }; + this.getAllFolds = function() { + var folds = []; + var foldLines = this.$foldData; + + for (var i = 0; i < foldLines.length; i++) + for (var j = 0; j < foldLines[i].folds.length; j++) + folds.push(foldLines[i].folds[j]); + + return folds; + }; + this.getFoldStringAt = function(row, column, trim, foldLine) { + foldLine = foldLine || this.getFoldLine(row); + if (!foldLine) + return null; + + var lastFold = { + end: { column: 0 } + }; + var str, fold; + for (var i = 0; i < foldLine.folds.length; i++) { + fold = foldLine.folds[i]; + var cmp = fold.range.compareEnd(row, column); + if (cmp == -1) { + str = this + .getLine(fold.start.row) + .substring(lastFold.end.column, fold.start.column); + break; + } + else if (cmp === 0) { + return null; + } + lastFold = fold; + } + if (!str) + str = this.getLine(fold.start.row).substring(lastFold.end.column); + + if (trim == -1) + return str.substring(0, column - lastFold.end.column); + else if (trim == 1) + return str.substring(column - lastFold.end.column); + else + return str; + }; + + this.getFoldLine = function(docRow, startFoldLine) { + var foldData = this.$foldData; + var i = 0; + if (startFoldLine) + i = foldData.indexOf(startFoldLine); + if (i == -1) + i = 0; + for (i; i < foldData.length; i++) { + var foldLine = foldData[i]; + if (foldLine.start.row <= docRow && foldLine.end.row >= docRow) { + return foldLine; + } else if (foldLine.end.row > docRow) { + return null; + } + } + return null; + }; + this.getNextFoldLine = function(docRow, startFoldLine) { + var foldData = this.$foldData; + var i = 0; + if (startFoldLine) + i = foldData.indexOf(startFoldLine); + if (i == -1) + i = 0; + for (i; i < foldData.length; i++) { + var foldLine = foldData[i]; + if (foldLine.end.row >= docRow) { + return foldLine; + } + } + return null; + }; + + this.getFoldedRowCount = function(first, last) { + var foldData = this.$foldData, rowCount = last-first+1; + for (var i = 0; i < foldData.length; i++) { + var foldLine = foldData[i], + end = foldLine.end.row, + start = foldLine.start.row; + if (end >= last) { + if (start < last) { + if (start >= first) + rowCount -= last-start; + else + rowCount = 0; // in one fold + } + break; + } else if (end >= first){ + if (start >= first) // fold inside range + rowCount -= end-start; + else + rowCount -= end-first+1; + } + } + return rowCount; + }; + + this.$addFoldLine = function(foldLine) { + this.$foldData.push(foldLine); + this.$foldData.sort(function(a, b) { + return a.start.row - b.start.row; + }); + return foldLine; + }; + this.addFold = function(placeholder, range) { + var foldData = this.$foldData; + var added = false; + var fold; + + if (placeholder instanceof Fold) + fold = placeholder; + else { + fold = new Fold(range, placeholder); + fold.collapseChildren = range.collapseChildren; + } + this.$clipRangeToDocument(fold.range); + + var startRow = fold.start.row; + var startColumn = fold.start.column; + var endRow = fold.end.row; + var endColumn = fold.end.column; + + var startFold = this.getFoldAt(startRow, startColumn, 1); + var endFold = this.getFoldAt(endRow, endColumn, -1); + if (startFold && endFold == startFold) + return startFold.addSubFold(fold); + + if (startFold && !startFold.range.isStart(startRow, startColumn)) + this.removeFold(startFold); + + if (endFold && !endFold.range.isEnd(endRow, endColumn)) + this.removeFold(endFold); + var folds = this.getFoldsInRange(fold.range); + if (folds.length > 0) { + this.removeFolds(folds); + if (!fold.collapseChildren) { + folds.forEach(function(subFold) { + fold.addSubFold(subFold); + }); + } + } + + for (var i = 0; i < foldData.length; i++) { + var foldLine = foldData[i]; + if (endRow == foldLine.start.row) { + foldLine.addFold(fold); + added = true; + break; + } else if (startRow == foldLine.end.row) { + foldLine.addFold(fold); + added = true; + if (!fold.sameRow) { + var foldLineNext = foldData[i + 1]; + if (foldLineNext && foldLineNext.start.row == endRow) { + foldLine.merge(foldLineNext); + break; + } + } + break; + } else if (endRow <= foldLine.start.row) { + break; + } + } + + if (!added) + foldLine = this.$addFoldLine(new FoldLine(this.$foldData, fold)); + + if (this.$useWrapMode) + this.$updateWrapData(foldLine.start.row, foldLine.start.row); + else + this.$updateRowLengthCache(foldLine.start.row, foldLine.start.row); + this.$modified = true; + this._signal("changeFold", { data: fold, action: "add" }); + + return fold; + }; + + this.addFolds = function(folds) { + folds.forEach(function(fold) { + this.addFold(fold); + }, this); + }; + + this.removeFold = function(fold) { + var foldLine = fold.foldLine; + var startRow = foldLine.start.row; + var endRow = foldLine.end.row; + + var foldLines = this.$foldData; + var folds = foldLine.folds; + if (folds.length == 1) { + foldLines.splice(foldLines.indexOf(foldLine), 1); + } else + if (foldLine.range.isEnd(fold.end.row, fold.end.column)) { + folds.pop(); + foldLine.end.row = folds[folds.length - 1].end.row; + foldLine.end.column = folds[folds.length - 1].end.column; + } else + if (foldLine.range.isStart(fold.start.row, fold.start.column)) { + folds.shift(); + foldLine.start.row = folds[0].start.row; + foldLine.start.column = folds[0].start.column; + } else + if (fold.sameRow) { + folds.splice(folds.indexOf(fold), 1); + } else + { + var newFoldLine = foldLine.split(fold.start.row, fold.start.column); + folds = newFoldLine.folds; + folds.shift(); + newFoldLine.start.row = folds[0].start.row; + newFoldLine.start.column = folds[0].start.column; + } + + if (!this.$updating) { + if (this.$useWrapMode) + this.$updateWrapData(startRow, endRow); + else + this.$updateRowLengthCache(startRow, endRow); + } + this.$modified = true; + this._signal("changeFold", { data: fold, action: "remove" }); + }; + + this.removeFolds = function(folds) { + var cloneFolds = []; + for (var i = 0; i < folds.length; i++) { + cloneFolds.push(folds[i]); + } + + cloneFolds.forEach(function(fold) { + this.removeFold(fold); + }, this); + this.$modified = true; + }; + + this.expandFold = function(fold) { + this.removeFold(fold); + fold.subFolds.forEach(function(subFold) { + fold.restoreRange(subFold); + this.addFold(subFold); + }, this); + if (fold.collapseChildren > 0) { + this.foldAll(fold.start.row+1, fold.end.row, fold.collapseChildren-1); + } + fold.subFolds = []; + }; + + this.expandFolds = function(folds) { + folds.forEach(function(fold) { + this.expandFold(fold); + }, this); + }; + + this.unfold = function(location, expandInner) { + var range, folds; + if (location == null) { + range = new Range(0, 0, this.getLength(), 0); + if (expandInner == null) expandInner = true; + } else if (typeof location == "number") { + range = new Range(location, 0, location, this.getLine(location).length); + } else if ("row" in location) { + range = Range.fromPoints(location, location); + } else if (Array.isArray(location)) { + folds = []; + location.forEach(function(range) { + folds = folds.concat(this.unfold(range)); + }, this); + return folds; + } else { + range = location; + } + + folds = this.getFoldsInRangeList(range); + var outermostFolds = folds; + while ( + folds.length == 1 + && Range.comparePoints(folds[0].start, range.start) < 0 + && Range.comparePoints(folds[0].end, range.end) > 0 + ) { + this.expandFolds(folds); + folds = this.getFoldsInRangeList(range); + } + + if (expandInner != false) { + this.removeFolds(folds); + } else { + this.expandFolds(folds); + } + if (outermostFolds.length) + return outermostFolds; + }; + this.isRowFolded = function(docRow, startFoldRow) { + return !!this.getFoldLine(docRow, startFoldRow); + }; + + this.getRowFoldEnd = function(docRow, startFoldRow) { + var foldLine = this.getFoldLine(docRow, startFoldRow); + return foldLine ? foldLine.end.row : docRow; + }; + + this.getRowFoldStart = function(docRow, startFoldRow) { + var foldLine = this.getFoldLine(docRow, startFoldRow); + return foldLine ? foldLine.start.row : docRow; + }; + + this.getFoldDisplayLine = function(foldLine, endRow, endColumn, startRow, startColumn) { + if (startRow == null) + startRow = foldLine.start.row; + if (startColumn == null) + startColumn = 0; + if (endRow == null) + endRow = foldLine.end.row; + if (endColumn == null) + endColumn = this.getLine(endRow).length; + var doc = this.doc; + var textLine = ""; + + foldLine.walk(function(placeholder, row, column, lastColumn) { + if (row < startRow) + return; + if (row == startRow) { + if (column < startColumn) + return; + lastColumn = Math.max(startColumn, lastColumn); + } + + if (placeholder != null) { + textLine += placeholder; + } else { + textLine += doc.getLine(row).substring(lastColumn, column); + } + }, endRow, endColumn); + return textLine; + }; + + this.getDisplayLine = function(row, endColumn, startRow, startColumn) { + var foldLine = this.getFoldLine(row); + + if (!foldLine) { + var line; + line = this.doc.getLine(row); + return line.substring(startColumn || 0, endColumn || line.length); + } else { + return this.getFoldDisplayLine( + foldLine, row, endColumn, startRow, startColumn); + } + }; + + this.$cloneFoldData = function() { + var fd = []; + fd = this.$foldData.map(function(foldLine) { + var folds = foldLine.folds.map(function(fold) { + return fold.clone(); + }); + return new FoldLine(fd, folds); + }); + + return fd; + }; + + this.toggleFold = function(tryToUnfold) { + var selection = this.selection; + var range = selection.getRange(); + var fold; + var bracketPos; + + if (range.isEmpty()) { + var cursor = range.start; + fold = this.getFoldAt(cursor.row, cursor.column); + + if (fold) { + this.expandFold(fold); + return; + } else if (bracketPos = this.findMatchingBracket(cursor)) { + if (range.comparePoint(bracketPos) == 1) { + range.end = bracketPos; + } else { + range.start = bracketPos; + range.start.column++; + range.end.column--; + } + } else if (bracketPos = this.findMatchingBracket({row: cursor.row, column: cursor.column + 1})) { + if (range.comparePoint(bracketPos) == 1) + range.end = bracketPos; + else + range.start = bracketPos; + + range.start.column++; + } else { + range = this.getCommentFoldRange(cursor.row, cursor.column) || range; + } + } else { + var folds = this.getFoldsInRange(range); + if (tryToUnfold && folds.length) { + this.expandFolds(folds); + return; + } else if (folds.length == 1 ) { + fold = folds[0]; + } + } + + if (!fold) + fold = this.getFoldAt(range.start.row, range.start.column); + + if (fold && fold.range.toString() == range.toString()) { + this.expandFold(fold); + return; + } + + var placeholder = "..."; + if (!range.isMultiLine()) { + placeholder = this.getTextRange(range); + if (placeholder.length < 4) + return; + placeholder = placeholder.trim().substring(0, 2) + ".."; + } + + this.addFold(placeholder, range); + }; + + this.getCommentFoldRange = function(row, column, dir) { + var iterator = new TokenIterator(this, row, column); + var token = iterator.getCurrentToken(); + var type = token && token.type; + if (token && /^comment|string/.test(type)) { + type = type.match(/comment|string/)[0]; + if (type == "comment") + type += "|doc-start"; + var re = new RegExp(type); + var range = new Range(); + if (dir != 1) { + do { + token = iterator.stepBackward(); + } while (token && re.test(token.type)); + iterator.stepForward(); + } + + range.start.row = iterator.getCurrentTokenRow(); + range.start.column = iterator.getCurrentTokenColumn() + 2; + + iterator = new TokenIterator(this, row, column); + + if (dir != -1) { + var lastRow = -1; + do { + token = iterator.stepForward(); + if (lastRow == -1) { + var state = this.getState(iterator.$row); + if (!re.test(state)) + lastRow = iterator.$row; + } else if (iterator.$row > lastRow) { + break; + } + } while (token && re.test(token.type)); + token = iterator.stepBackward(); + } else + token = iterator.getCurrentToken(); + + range.end.row = iterator.getCurrentTokenRow(); + range.end.column = iterator.getCurrentTokenColumn() + token.value.length - 2; + return range; + } + }; + + this.foldAll = function(startRow, endRow, depth, test) { + if (depth == undefined) + depth = 100000; // JSON.stringify doesn't hanle Infinity + var foldWidgets = this.foldWidgets; + if (!foldWidgets) + return; // mode doesn't support folding + endRow = endRow || this.getLength(); + startRow = startRow || 0; + for (var row = startRow; row < endRow; row++) { + if (foldWidgets[row] == null) + foldWidgets[row] = this.getFoldWidget(row); + if (foldWidgets[row] != "start") + continue; + + if (test && !test(row)) continue; + + var range = this.getFoldWidgetRange(row); + if (range && range.isMultiLine() + && range.end.row <= endRow + && range.start.row >= startRow + ) { + row = range.end.row; + range.collapseChildren = depth; + this.addFold("...", range); + } + } + }; + + this.foldToLevel = function(level) { + this.foldAll(); + while (level-- > 0) + this.unfold(null, false); + }; + + this.foldAllComments = function() { + var session = this; + this.foldAll(null, null, null, function(row) { + var tokens = session.getTokens(row); + for (var i = 0; i < tokens.length; i++) { + var token = tokens[i]; + if (token.type == "text" && /^\s+$/.test(token.value)) + continue; + if (/comment/.test(token.type)) + return true; + return false; + } + }); + }; + this.$foldStyles = { + "manual": 1, + "markbegin": 1, + "markbeginend": 1 + }; + this.$foldStyle = "markbegin"; + this.setFoldStyle = function(style) { + if (!this.$foldStyles[style]) + throw new Error("invalid fold style: " + style + "[" + Object.keys(this.$foldStyles).join(", ") + "]"); + + if (this.$foldStyle == style) + return; + + this.$foldStyle = style; + + if (style == "manual") + this.unfold(); + var mode = this.$foldMode; + this.$setFolding(null); + this.$setFolding(mode); + }; + + this.$setFolding = function(foldMode) { + if (this.$foldMode == foldMode) + return; + + this.$foldMode = foldMode; + + this.off('change', this.$updateFoldWidgets); + this.off('tokenizerUpdate', this.$tokenizerUpdateFoldWidgets); + this._signal("changeAnnotation"); + + if (!foldMode || this.$foldStyle == "manual") { + this.foldWidgets = null; + return; + } + + this.foldWidgets = []; + this.getFoldWidget = foldMode.getFoldWidget.bind(foldMode, this, this.$foldStyle); + this.getFoldWidgetRange = foldMode.getFoldWidgetRange.bind(foldMode, this, this.$foldStyle); + + this.$updateFoldWidgets = this.updateFoldWidgets.bind(this); + this.$tokenizerUpdateFoldWidgets = this.tokenizerUpdateFoldWidgets.bind(this); + this.on('change', this.$updateFoldWidgets); + this.on('tokenizerUpdate', this.$tokenizerUpdateFoldWidgets); + }; + + this.getParentFoldRangeData = function (row, ignoreCurrent) { + var fw = this.foldWidgets; + if (!fw || (ignoreCurrent && fw[row])) + return {}; + + var i = row - 1, firstRange; + while (i >= 0) { + var c = fw[i]; + if (c == null) + c = fw[i] = this.getFoldWidget(i); + + if (c == "start") { + var range = this.getFoldWidgetRange(i); + if (!firstRange) + firstRange = range; + if (range && range.end.row >= row) + break; + } + i--; + } + + return { + range: i !== -1 && range, + firstRange: firstRange + }; + }; + + this.onFoldWidgetClick = function(row, e) { + e = e.domEvent; + var options = { + children: e.shiftKey, + all: e.ctrlKey || e.metaKey, + siblings: e.altKey + }; + + var range = this.$toggleFoldWidget(row, options); + if (!range) { + var el = (e.target || e.srcElement); + if (el && /ace_fold-widget/.test(el.className)) + el.className += " ace_invalid"; + } + }; + + this.$toggleFoldWidget = function(row, options) { + if (!this.getFoldWidget) + return; + var type = this.getFoldWidget(row); + var line = this.getLine(row); + + var dir = type === "end" ? -1 : 1; + var fold = this.getFoldAt(row, dir === -1 ? 0 : line.length, dir); + + if (fold) { + if (options.children || options.all) + this.removeFold(fold); + else + this.expandFold(fold); + return fold; + } + + var range = this.getFoldWidgetRange(row, true); + if (range && !range.isMultiLine()) { + fold = this.getFoldAt(range.start.row, range.start.column, 1); + if (fold && range.isEqual(fold.range)) { + this.removeFold(fold); + return fold; + } + } + + if (options.siblings) { + var data = this.getParentFoldRangeData(row); + if (data.range) { + var startRow = data.range.start.row + 1; + var endRow = data.range.end.row; + } + this.foldAll(startRow, endRow, options.all ? 10000 : 0); + } else if (options.children) { + endRow = range ? range.end.row : this.getLength(); + this.foldAll(row + 1, endRow, options.all ? 10000 : 0); + } else if (range) { + if (options.all) + range.collapseChildren = 10000; + this.addFold("...", range); + } + + return range; + }; + + + + this.toggleFoldWidget = function(toggleParent) { + var row = this.selection.getCursor().row; + row = this.getRowFoldStart(row); + var range = this.$toggleFoldWidget(row, {}); + + if (range) + return; + var data = this.getParentFoldRangeData(row, true); + range = data.range || data.firstRange; + + if (range) { + row = range.start.row; + var fold = this.getFoldAt(row, this.getLine(row).length, 1); + + if (fold) { + this.removeFold(fold); + } else { + this.addFold("...", range); + } + } + }; + + this.updateFoldWidgets = function(delta) { + var firstRow = delta.start.row; + var len = delta.end.row - firstRow; + + if (len === 0) { + this.foldWidgets[firstRow] = null; + } else if (delta.action == 'remove') { + this.foldWidgets.splice(firstRow, len + 1, null); + } else { + var args = Array(len + 1); + args.unshift(firstRow, 1); + this.foldWidgets.splice.apply(this.foldWidgets, args); + } + }; + this.tokenizerUpdateFoldWidgets = function(e) { + var rows = e.data; + if (rows.first != rows.last) { + if (this.foldWidgets.length > rows.first) + this.foldWidgets.splice(rows.first, this.foldWidgets.length); + } + }; +} + +exports.Folding = Folding; + +}); + +ace.define("ace/edit_session/bracket_match",["require","exports","module","ace/token_iterator","ace/range"], function(require, exports, module) { +"use strict"; + +var TokenIterator = require("../token_iterator").TokenIterator; +var Range = require("../range").Range; + + +function BracketMatch() { + + this.findMatchingBracket = function(position, chr) { + if (position.column == 0) return null; + + var charBeforeCursor = chr || this.getLine(position.row).charAt(position.column-1); + if (charBeforeCursor == "") return null; + + var match = charBeforeCursor.match(/([\(\[\{])|([\)\]\}])/); + if (!match) + return null; + + if (match[1]) + return this.$findClosingBracket(match[1], position); + else + return this.$findOpeningBracket(match[2], position); + }; + + this.getBracketRange = function(pos) { + var line = this.getLine(pos.row); + var before = true, range; + + var chr = line.charAt(pos.column - 1); + var match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + if (!match) { + chr = line.charAt(pos.column); + pos = {row: pos.row, column: pos.column + 1}; + match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + before = false; + } + if (!match) + return null; + + if (match[1]) { + var bracketPos = this.$findClosingBracket(match[1], pos); + if (!bracketPos) + return null; + range = Range.fromPoints(pos, bracketPos); + if (!before) { + range.end.column++; + range.start.column--; + } + range.cursor = range.end; + } else { + var bracketPos = this.$findOpeningBracket(match[2], pos); + if (!bracketPos) + return null; + range = Range.fromPoints(bracketPos, pos); + if (!before) { + range.start.column++; + range.end.column--; + } + range.cursor = range.start; + } + + return range; + }; + this.getMatchingBracketRanges = function(pos) { + var line = this.getLine(pos.row); + + var chr = line.charAt(pos.column - 1); + var match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + if (!match) { + chr = line.charAt(pos.column); + pos = {row: pos.row, column: pos.column + 1}; + match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + } + + if (!match) + return null; + + var startRange = new Range(pos.row, pos.column - 1, pos.row, pos.column); + var bracketPos = match[1] ? this.$findClosingBracket(match[1], pos) + : this.$findOpeningBracket(match[2], pos); + if (!bracketPos) + return [startRange]; + var endRange = new Range(bracketPos.row, bracketPos.column, bracketPos.row, bracketPos.column + 1); + + return [startRange, endRange]; + }; + + this.$brackets = { + ")": "(", + "(": ")", + "]": "[", + "[": "]", + "{": "}", + "}": "{", + "<": ">", + ">": "<" + }; + + this.$findOpeningBracket = function(bracket, position, typeRe) { + var openBracket = this.$brackets[bracket]; + var depth = 1; + + var iterator = new TokenIterator(this, position.row, position.column); + var token = iterator.getCurrentToken(); + if (!token) + token = iterator.stepForward(); + if (!token) + return; + + if (!typeRe){ + typeRe = new RegExp( + "(\\.?" + + token.type.replace(".", "\\.").replace("rparen", ".paren") + .replace(/\b(?:end)\b/, "(?:start|begin|end)") + + ")+" + ); + } + var valueIndex = position.column - iterator.getCurrentTokenColumn() - 2; + var value = token.value; + + while (true) { + + while (valueIndex >= 0) { + var chr = value.charAt(valueIndex); + if (chr == openBracket) { + depth -= 1; + if (depth == 0) { + return {row: iterator.getCurrentTokenRow(), + column: valueIndex + iterator.getCurrentTokenColumn()}; + } + } + else if (chr == bracket) { + depth += 1; + } + valueIndex -= 1; + } + do { + token = iterator.stepBackward(); + } while (token && !typeRe.test(token.type)); + + if (token == null) + break; + + value = token.value; + valueIndex = value.length - 1; + } + + return null; + }; + + this.$findClosingBracket = function(bracket, position, typeRe) { + var closingBracket = this.$brackets[bracket]; + var depth = 1; + + var iterator = new TokenIterator(this, position.row, position.column); + var token = iterator.getCurrentToken(); + if (!token) + token = iterator.stepForward(); + if (!token) + return; + + if (!typeRe){ + typeRe = new RegExp( + "(\\.?" + + token.type.replace(".", "\\.").replace("lparen", ".paren") + .replace(/\b(?:start|begin)\b/, "(?:start|begin|end)") + + ")+" + ); + } + var valueIndex = position.column - iterator.getCurrentTokenColumn(); + + while (true) { + + var value = token.value; + var valueLength = value.length; + while (valueIndex < valueLength) { + var chr = value.charAt(valueIndex); + if (chr == closingBracket) { + depth -= 1; + if (depth == 0) { + return {row: iterator.getCurrentTokenRow(), + column: valueIndex + iterator.getCurrentTokenColumn()}; + } + } + else if (chr == bracket) { + depth += 1; + } + valueIndex += 1; + } + do { + token = iterator.stepForward(); + } while (token && !typeRe.test(token.type)); + + if (token == null) + break; + + valueIndex = 0; + } + + return null; + }; +} +exports.BracketMatch = BracketMatch; + +}); + +ace.define("ace/edit_session",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/bidihandler","ace/config","ace/lib/event_emitter","ace/selection","ace/mode/text","ace/range","ace/document","ace/background_tokenizer","ace/search_highlight","ace/edit_session/folding","ace/edit_session/bracket_match"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var lang = require("./lib/lang"); +var BidiHandler = require("./bidihandler").BidiHandler; +var config = require("./config"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var Selection = require("./selection").Selection; +var TextMode = require("./mode/text").Mode; +var Range = require("./range").Range; +var Document = require("./document").Document; +var BackgroundTokenizer = require("./background_tokenizer").BackgroundTokenizer; +var SearchHighlight = require("./search_highlight").SearchHighlight; + +var EditSession = function(text, mode) { + this.$breakpoints = []; + this.$decorations = []; + this.$frontMarkers = {}; + this.$backMarkers = {}; + this.$markerId = 1; + this.$undoSelect = true; + + this.$foldData = []; + this.id = "session" + (++EditSession.$uid); + this.$foldData.toString = function() { + return this.join("\n"); + }; + this.on("changeFold", this.onChangeFold.bind(this)); + this.$onChange = this.onChange.bind(this); + + if (typeof text != "object" || !text.getLine) + text = new Document(text); + + this.setDocument(text); + this.selection = new Selection(this); + this.$bidiHandler = new BidiHandler(this); + + config.resetOptions(this); + this.setMode(mode); + config._signal("session", this); +}; + + +EditSession.$uid = 0; + +(function() { + + oop.implement(this, EventEmitter); + this.setDocument = function(doc) { + if (this.doc) + this.doc.off("change", this.$onChange); + + this.doc = doc; + doc.on("change", this.$onChange); + + if (this.bgTokenizer) + this.bgTokenizer.setDocument(this.getDocument()); + + this.resetCaches(); + }; + this.getDocument = function() { + return this.doc; + }; + this.$resetRowCache = function(docRow) { + if (!docRow) { + this.$docRowCache = []; + this.$screenRowCache = []; + return; + } + var l = this.$docRowCache.length; + var i = this.$getRowCacheIndex(this.$docRowCache, docRow) + 1; + if (l > i) { + this.$docRowCache.splice(i, l); + this.$screenRowCache.splice(i, l); + } + }; + + this.$getRowCacheIndex = function(cacheArray, val) { + var low = 0; + var hi = cacheArray.length - 1; + + while (low <= hi) { + var mid = (low + hi) >> 1; + var c = cacheArray[mid]; + + if (val > c) + low = mid + 1; + else if (val < c) + hi = mid - 1; + else + return mid; + } + + return low -1; + }; + + this.resetCaches = function() { + this.$modified = true; + this.$wrapData = []; + this.$rowLengthCache = []; + this.$resetRowCache(0); + if (this.bgTokenizer) + this.bgTokenizer.start(0); + }; + + this.onChangeFold = function(e) { + var fold = e.data; + this.$resetRowCache(fold.start.row); + }; + + this.onChange = function(delta) { + this.$modified = true; + this.$bidiHandler.onChange(delta); + this.$resetRowCache(delta.start.row); + + var removedFolds = this.$updateInternalDataOnChange(delta); + if (!this.$fromUndo && this.$undoManager) { + if (removedFolds && removedFolds.length) { + this.$undoManager.add({ + action: "removeFolds", + folds: removedFolds + }, this.mergeUndoDeltas); + this.mergeUndoDeltas = true; + } + this.$undoManager.add(delta, this.mergeUndoDeltas); + this.mergeUndoDeltas = true; + + this.$informUndoManager.schedule(); + } + + this.bgTokenizer && this.bgTokenizer.$updateOnChange(delta); + this._signal("change", delta); + }; + this.setValue = function(text) { + this.doc.setValue(text); + this.selection.moveTo(0, 0); + + this.$resetRowCache(0); + this.setUndoManager(this.$undoManager); + this.getUndoManager().reset(); + }; + this.getValue = + this.toString = function() { + return this.doc.getValue(); + }; + this.getSelection = function() { + return this.selection; + }; + this.getState = function(row) { + return this.bgTokenizer.getState(row); + }; + this.getTokens = function(row) { + return this.bgTokenizer.getTokens(row); + }; + this.getTokenAt = function(row, column) { + var tokens = this.bgTokenizer.getTokens(row); + var token, c = 0; + if (column == null) { + var i = tokens.length - 1; + c = this.getLine(row).length; + } else { + for (var i = 0; i < tokens.length; i++) { + c += tokens[i].value.length; + if (c >= column) + break; + } + } + token = tokens[i]; + if (!token) + return null; + token.index = i; + token.start = c - token.value.length; + return token; + }; + this.setUndoManager = function(undoManager) { + this.$undoManager = undoManager; + + if (this.$informUndoManager) + this.$informUndoManager.cancel(); + + if (undoManager) { + var self = this; + undoManager.addSession(this); + this.$syncInformUndoManager = function() { + self.$informUndoManager.cancel(); + self.mergeUndoDeltas = false; + }; + this.$informUndoManager = lang.delayedCall(this.$syncInformUndoManager); + } else { + this.$syncInformUndoManager = function() {}; + } + }; + this.markUndoGroup = function() { + if (this.$syncInformUndoManager) + this.$syncInformUndoManager(); + }; + + this.$defaultUndoManager = { + undo: function() {}, + redo: function() {}, + hasUndo: function() {}, + hasRedo: function() {}, + reset: function() {}, + add: function() {}, + addSelection: function() {}, + startNewGroup: function() {}, + addSession: function() {} + }; + this.getUndoManager = function() { + return this.$undoManager || this.$defaultUndoManager; + }; + this.getTabString = function() { + if (this.getUseSoftTabs()) { + return lang.stringRepeat(" ", this.getTabSize()); + } else { + return "\t"; + } + }; + this.setUseSoftTabs = function(val) { + this.setOption("useSoftTabs", val); + }; + this.getUseSoftTabs = function() { + return this.$useSoftTabs && !this.$mode.$indentWithTabs; + }; + this.setTabSize = function(tabSize) { + this.setOption("tabSize", tabSize); + }; + this.getTabSize = function() { + return this.$tabSize; + }; + this.isTabStop = function(position) { + return this.$useSoftTabs && (position.column % this.$tabSize === 0); + }; + this.setNavigateWithinSoftTabs = function (navigateWithinSoftTabs) { + this.setOption("navigateWithinSoftTabs", navigateWithinSoftTabs); + }; + this.getNavigateWithinSoftTabs = function() { + return this.$navigateWithinSoftTabs; + }; + + this.$overwrite = false; + this.setOverwrite = function(overwrite) { + this.setOption("overwrite", overwrite); + }; + this.getOverwrite = function() { + return this.$overwrite; + }; + this.toggleOverwrite = function() { + this.setOverwrite(!this.$overwrite); + }; + this.addGutterDecoration = function(row, className) { + if (!this.$decorations[row]) + this.$decorations[row] = ""; + this.$decorations[row] += " " + className; + this._signal("changeBreakpoint", {}); + }; + this.removeGutterDecoration = function(row, className) { + this.$decorations[row] = (this.$decorations[row] || "").replace(" " + className, ""); + this._signal("changeBreakpoint", {}); + }; + this.getBreakpoints = function() { + return this.$breakpoints; + }; + this.setBreakpoints = function(rows) { + this.$breakpoints = []; + for (var i=0; i 0) + inToken = !!line.charAt(column - 1).match(this.tokenRe); + + if (!inToken) + inToken = !!line.charAt(column).match(this.tokenRe); + + if (inToken) + var re = this.tokenRe; + else if (/^\s+$/.test(line.slice(column-1, column+1))) + var re = /\s/; + else + var re = this.nonTokenRe; + + var start = column; + if (start > 0) { + do { + start--; + } + while (start >= 0 && line.charAt(start).match(re)); + start++; + } + + var end = column; + while (end < line.length && line.charAt(end).match(re)) { + end++; + } + + return new Range(row, start, row, end); + }; + this.getAWordRange = function(row, column) { + var wordRange = this.getWordRange(row, column); + var line = this.getLine(wordRange.end.row); + + while (line.charAt(wordRange.end.column).match(/[ \t]/)) { + wordRange.end.column += 1; + } + return wordRange; + }; + this.setNewLineMode = function(newLineMode) { + this.doc.setNewLineMode(newLineMode); + }; + this.getNewLineMode = function() { + return this.doc.getNewLineMode(); + }; + this.setUseWorker = function(useWorker) { this.setOption("useWorker", useWorker); }; + this.getUseWorker = function() { return this.$useWorker; }; + this.onReloadTokenizer = function(e) { + var rows = e.data; + this.bgTokenizer.start(rows.first); + this._signal("tokenizerUpdate", e); + }; + + this.$modes = config.$modes; + this.$mode = null; + this.$modeId = null; + this.setMode = function(mode, cb) { + if (mode && typeof mode === "object") { + if (mode.getTokenizer) + return this.$onChangeMode(mode); + var options = mode; + var path = options.path; + } else { + path = mode || "ace/mode/text"; + } + if (!this.$modes["ace/mode/text"]) + this.$modes["ace/mode/text"] = new TextMode(); + + if (this.$modes[path] && !options) { + this.$onChangeMode(this.$modes[path]); + cb && cb(); + return; + } + this.$modeId = path; + config.loadModule(["mode", path], function(m) { + if (this.$modeId !== path) + return cb && cb(); + if (this.$modes[path] && !options) { + this.$onChangeMode(this.$modes[path]); + } else if (m && m.Mode) { + m = new m.Mode(options); + if (!options) { + this.$modes[path] = m; + m.$id = path; + } + this.$onChangeMode(m); + } + cb && cb(); + }.bind(this)); + if (!this.$mode) + this.$onChangeMode(this.$modes["ace/mode/text"], true); + }; + + this.$onChangeMode = function(mode, $isPlaceholder) { + if (!$isPlaceholder) + this.$modeId = mode.$id; + if (this.$mode === mode) + return; + + var oldMode = this.$mode; + this.$mode = mode; + + this.$stopWorker(); + + if (this.$useWorker) + this.$startWorker(); + + var tokenizer = mode.getTokenizer(); + + if(tokenizer.on !== undefined) { + var onReloadTokenizer = this.onReloadTokenizer.bind(this); + tokenizer.on("update", onReloadTokenizer); + } + + if (!this.bgTokenizer) { + this.bgTokenizer = new BackgroundTokenizer(tokenizer); + var _self = this; + this.bgTokenizer.on("update", function(e) { + _self._signal("tokenizerUpdate", e); + }); + } else { + this.bgTokenizer.setTokenizer(tokenizer); + } + + this.bgTokenizer.setDocument(this.getDocument()); + + this.tokenRe = mode.tokenRe; + this.nonTokenRe = mode.nonTokenRe; + + + if (!$isPlaceholder) { + if (mode.attachToSession) + mode.attachToSession(this); + this.$options.wrapMethod.set.call(this, this.$wrapMethod); + this.$setFolding(mode.foldingRules); + this.bgTokenizer.start(0); + this._emit("changeMode", {oldMode: oldMode, mode: mode}); + } + }; + + this.$stopWorker = function() { + if (this.$worker) { + this.$worker.terminate(); + this.$worker = null; + } + }; + + this.$startWorker = function() { + try { + this.$worker = this.$mode.createWorker(this); + } catch (e) { + config.warn("Could not load worker", e); + this.$worker = null; + } + }; + this.getMode = function() { + return this.$mode; + }; + + this.$scrollTop = 0; + this.setScrollTop = function(scrollTop) { + if (this.$scrollTop === scrollTop || isNaN(scrollTop)) + return; + + this.$scrollTop = scrollTop; + this._signal("changeScrollTop", scrollTop); + }; + this.getScrollTop = function() { + return this.$scrollTop; + }; + + this.$scrollLeft = 0; + this.setScrollLeft = function(scrollLeft) { + if (this.$scrollLeft === scrollLeft || isNaN(scrollLeft)) + return; + + this.$scrollLeft = scrollLeft; + this._signal("changeScrollLeft", scrollLeft); + }; + this.getScrollLeft = function() { + return this.$scrollLeft; + }; + this.getScreenWidth = function() { + this.$computeWidth(); + if (this.lineWidgets) + return Math.max(this.getLineWidgetMaxWidth(), this.screenWidth); + return this.screenWidth; + }; + + this.getLineWidgetMaxWidth = function() { + if (this.lineWidgetsWidth != null) return this.lineWidgetsWidth; + var width = 0; + this.lineWidgets.forEach(function(w) { + if (w && w.screenWidth > width) + width = w.screenWidth; + }); + return this.lineWidgetWidth = width; + }; + + this.$computeWidth = function(force) { + if (this.$modified || force) { + this.$modified = false; + + if (this.$useWrapMode) + return this.screenWidth = this.$wrapLimit; + + var lines = this.doc.getAllLines(); + var cache = this.$rowLengthCache; + var longestScreenLine = 0; + var foldIndex = 0; + var foldLine = this.$foldData[foldIndex]; + var foldStart = foldLine ? foldLine.start.row : Infinity; + var len = lines.length; + + for (var i = 0; i < len; i++) { + if (i > foldStart) { + i = foldLine.end.row + 1; + if (i >= len) + break; + foldLine = this.$foldData[foldIndex++]; + foldStart = foldLine ? foldLine.start.row : Infinity; + } + + if (cache[i] == null) + cache[i] = this.$getStringScreenWidth(lines[i])[0]; + + if (cache[i] > longestScreenLine) + longestScreenLine = cache[i]; + } + this.screenWidth = longestScreenLine; + } + }; + this.getLine = function(row) { + return this.doc.getLine(row); + }; + this.getLines = function(firstRow, lastRow) { + return this.doc.getLines(firstRow, lastRow); + }; + this.getLength = function() { + return this.doc.getLength(); + }; + this.getTextRange = function(range) { + return this.doc.getTextRange(range || this.selection.getRange()); + }; + this.insert = function(position, text) { + return this.doc.insert(position, text); + }; + this.remove = function(range) { + return this.doc.remove(range); + }; + this.removeFullLines = function(firstRow, lastRow){ + return this.doc.removeFullLines(firstRow, lastRow); + }; + this.undoChanges = function(deltas, dontSelect) { + if (!deltas.length) + return; + + this.$fromUndo = true; + for (var i = deltas.length - 1; i != -1; i--) { + var delta = deltas[i]; + if (delta.action == "insert" || delta.action == "remove") { + this.doc.revertDelta(delta); + } else if (delta.folds) { + this.addFolds(delta.folds); + } + } + if (!dontSelect && this.$undoSelect) { + if (deltas.selectionBefore) + this.selection.fromJSON(deltas.selectionBefore); + else + this.selection.setRange(this.$getUndoSelection(deltas, true)); + } + this.$fromUndo = false; + }; + this.redoChanges = function(deltas, dontSelect) { + if (!deltas.length) + return; + + this.$fromUndo = true; + for (var i = 0; i < deltas.length; i++) { + var delta = deltas[i]; + if (delta.action == "insert" || delta.action == "remove") { + this.doc.$safeApplyDelta(delta); + } + } + + if (!dontSelect && this.$undoSelect) { + if (deltas.selectionAfter) + this.selection.fromJSON(deltas.selectionAfter); + else + this.selection.setRange(this.$getUndoSelection(deltas, false)); + } + this.$fromUndo = false; + }; + this.setUndoSelect = function(enable) { + this.$undoSelect = enable; + }; + + this.$getUndoSelection = function(deltas, isUndo) { + function isInsert(delta) { + return isUndo ? delta.action !== "insert" : delta.action === "insert"; + } + + var range, point; + + for (var i = 0; i < deltas.length; i++) { + var delta = deltas[i]; + if (!delta.start) continue; // skip folds + if (!range) { + if (isInsert(delta)) { + range = Range.fromPoints(delta.start, delta.end); + } else { + range = Range.fromPoints(delta.start, delta.start); + } + continue; + } + + if (isInsert(delta)) { + point = delta.start; + if (range.compare(point.row, point.column) == -1) { + range.setStart(point); + } + point = delta.end; + if (range.compare(point.row, point.column) == 1) { + range.setEnd(point); + } + } else { + point = delta.start; + if (range.compare(point.row, point.column) == -1) { + range = Range.fromPoints(delta.start, delta.start); + } + } + } + return range; + }; + this.replace = function(range, text) { + return this.doc.replace(range, text); + }; + this.moveText = function(fromRange, toPosition, copy) { + var text = this.getTextRange(fromRange); + var folds = this.getFoldsInRange(fromRange); + + var toRange = Range.fromPoints(toPosition, toPosition); + if (!copy) { + this.remove(fromRange); + var rowDiff = fromRange.start.row - fromRange.end.row; + var collDiff = rowDiff ? -fromRange.end.column : fromRange.start.column - fromRange.end.column; + if (collDiff) { + if (toRange.start.row == fromRange.end.row && toRange.start.column > fromRange.end.column) + toRange.start.column += collDiff; + if (toRange.end.row == fromRange.end.row && toRange.end.column > fromRange.end.column) + toRange.end.column += collDiff; + } + if (rowDiff && toRange.start.row >= fromRange.end.row) { + toRange.start.row += rowDiff; + toRange.end.row += rowDiff; + } + } + + toRange.end = this.insert(toRange.start, text); + if (folds.length) { + var oldStart = fromRange.start; + var newStart = toRange.start; + var rowDiff = newStart.row - oldStart.row; + var collDiff = newStart.column - oldStart.column; + this.addFolds(folds.map(function(x) { + x = x.clone(); + if (x.start.row == oldStart.row) + x.start.column += collDiff; + if (x.end.row == oldStart.row) + x.end.column += collDiff; + x.start.row += rowDiff; + x.end.row += rowDiff; + return x; + })); + } + + return toRange; + }; + this.indentRows = function(startRow, endRow, indentString) { + indentString = indentString.replace(/\t/g, this.getTabString()); + for (var row=startRow; row<=endRow; row++) + this.doc.insertInLine({row: row, column: 0}, indentString); + }; + this.outdentRows = function (range) { + var rowRange = range.collapseRows(); + var deleteRange = new Range(0, 0, 0, 0); + var size = this.getTabSize(); + + for (var i = rowRange.start.row; i <= rowRange.end.row; ++i) { + var line = this.getLine(i); + + deleteRange.start.row = i; + deleteRange.end.row = i; + for (var j = 0; j < size; ++j) + if (line.charAt(j) != ' ') + break; + if (j < size && line.charAt(j) == '\t') { + deleteRange.start.column = j; + deleteRange.end.column = j + 1; + } else { + deleteRange.start.column = 0; + deleteRange.end.column = j; + } + this.remove(deleteRange); + } + }; + + this.$moveLines = function(firstRow, lastRow, dir) { + firstRow = this.getRowFoldStart(firstRow); + lastRow = this.getRowFoldEnd(lastRow); + if (dir < 0) { + var row = this.getRowFoldStart(firstRow + dir); + if (row < 0) return 0; + var diff = row-firstRow; + } else if (dir > 0) { + var row = this.getRowFoldEnd(lastRow + dir); + if (row > this.doc.getLength()-1) return 0; + var diff = row-lastRow; + } else { + firstRow = this.$clipRowToDocument(firstRow); + lastRow = this.$clipRowToDocument(lastRow); + var diff = lastRow - firstRow + 1; + } + + var range = new Range(firstRow, 0, lastRow, Number.MAX_VALUE); + var folds = this.getFoldsInRange(range).map(function(x){ + x = x.clone(); + x.start.row += diff; + x.end.row += diff; + return x; + }); + + var lines = dir == 0 + ? this.doc.getLines(firstRow, lastRow) + : this.doc.removeFullLines(firstRow, lastRow); + this.doc.insertFullLines(firstRow+diff, lines); + folds.length && this.addFolds(folds); + return diff; + }; + this.moveLinesUp = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, -1); + }; + this.moveLinesDown = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, 1); + }; + this.duplicateLines = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, 0); + }; + + + this.$clipRowToDocument = function(row) { + return Math.max(0, Math.min(row, this.doc.getLength()-1)); + }; + + this.$clipColumnToRow = function(row, column) { + if (column < 0) + return 0; + return Math.min(this.doc.getLine(row).length, column); + }; + + + this.$clipPositionToDocument = function(row, column) { + column = Math.max(0, column); + + if (row < 0) { + row = 0; + column = 0; + } else { + var len = this.doc.getLength(); + if (row >= len) { + row = len - 1; + column = this.doc.getLine(len-1).length; + } else { + column = Math.min(this.doc.getLine(row).length, column); + } + } + + return { + row: row, + column: column + }; + }; + + this.$clipRangeToDocument = function(range) { + if (range.start.row < 0) { + range.start.row = 0; + range.start.column = 0; + } else { + range.start.column = this.$clipColumnToRow( + range.start.row, + range.start.column + ); + } + + var len = this.doc.getLength() - 1; + if (range.end.row > len) { + range.end.row = len; + range.end.column = this.doc.getLine(len).length; + } else { + range.end.column = this.$clipColumnToRow( + range.end.row, + range.end.column + ); + } + return range; + }; + this.$wrapLimit = 80; + this.$useWrapMode = false; + this.$wrapLimitRange = { + min : null, + max : null + }; + this.setUseWrapMode = function(useWrapMode) { + if (useWrapMode != this.$useWrapMode) { + this.$useWrapMode = useWrapMode; + this.$modified = true; + this.$resetRowCache(0); + if (useWrapMode) { + var len = this.getLength(); + this.$wrapData = Array(len); + this.$updateWrapData(0, len - 1); + } + + this._signal("changeWrapMode"); + } + }; + this.getUseWrapMode = function() { + return this.$useWrapMode; + }; + this.setWrapLimitRange = function(min, max) { + if (this.$wrapLimitRange.min !== min || this.$wrapLimitRange.max !== max) { + this.$wrapLimitRange = { min: min, max: max }; + this.$modified = true; + this.$bidiHandler.markAsDirty(); + if (this.$useWrapMode) + this._signal("changeWrapMode"); + } + }; + this.adjustWrapLimit = function(desiredLimit, $printMargin) { + var limits = this.$wrapLimitRange; + if (limits.max < 0) + limits = {min: $printMargin, max: $printMargin}; + var wrapLimit = this.$constrainWrapLimit(desiredLimit, limits.min, limits.max); + if (wrapLimit != this.$wrapLimit && wrapLimit > 1) { + this.$wrapLimit = wrapLimit; + this.$modified = true; + if (this.$useWrapMode) { + this.$updateWrapData(0, this.getLength() - 1); + this.$resetRowCache(0); + this._signal("changeWrapLimit"); + } + return true; + } + return false; + }; + + this.$constrainWrapLimit = function(wrapLimit, min, max) { + if (min) + wrapLimit = Math.max(min, wrapLimit); + + if (max) + wrapLimit = Math.min(max, wrapLimit); + + return wrapLimit; + }; + this.getWrapLimit = function() { + return this.$wrapLimit; + }; + this.setWrapLimit = function (limit) { + this.setWrapLimitRange(limit, limit); + }; + this.getWrapLimitRange = function() { + return { + min : this.$wrapLimitRange.min, + max : this.$wrapLimitRange.max + }; + }; + + this.$updateInternalDataOnChange = function(delta) { + var useWrapMode = this.$useWrapMode; + var action = delta.action; + var start = delta.start; + var end = delta.end; + var firstRow = start.row; + var lastRow = end.row; + var len = lastRow - firstRow; + var removedFolds = null; + + this.$updating = true; + if (len != 0) { + if (action === "remove") { + this[useWrapMode ? "$wrapData" : "$rowLengthCache"].splice(firstRow, len); + + var foldLines = this.$foldData; + removedFolds = this.getFoldsInRange(delta); + this.removeFolds(removedFolds); + + var foldLine = this.getFoldLine(end.row); + var idx = 0; + if (foldLine) { + foldLine.addRemoveChars(end.row, end.column, start.column - end.column); + foldLine.shiftRow(-len); + + var foldLineBefore = this.getFoldLine(firstRow); + if (foldLineBefore && foldLineBefore !== foldLine) { + foldLineBefore.merge(foldLine); + foldLine = foldLineBefore; + } + idx = foldLines.indexOf(foldLine) + 1; + } + + for (idx; idx < foldLines.length; idx++) { + var foldLine = foldLines[idx]; + if (foldLine.start.row >= end.row) { + foldLine.shiftRow(-len); + } + } + + lastRow = firstRow; + } else { + var args = Array(len); + args.unshift(firstRow, 0); + var arr = useWrapMode ? this.$wrapData : this.$rowLengthCache; + arr.splice.apply(arr, args); + var foldLines = this.$foldData; + var foldLine = this.getFoldLine(firstRow); + var idx = 0; + if (foldLine) { + var cmp = foldLine.range.compareInside(start.row, start.column); + if (cmp == 0) { + foldLine = foldLine.split(start.row, start.column); + if (foldLine) { + foldLine.shiftRow(len); + foldLine.addRemoveChars(lastRow, 0, end.column - start.column); + } + } else + if (cmp == -1) { + foldLine.addRemoveChars(firstRow, 0, end.column - start.column); + foldLine.shiftRow(len); + } + idx = foldLines.indexOf(foldLine) + 1; + } + + for (idx; idx < foldLines.length; idx++) { + var foldLine = foldLines[idx]; + if (foldLine.start.row >= firstRow) { + foldLine.shiftRow(len); + } + } + } + } else { + len = Math.abs(delta.start.column - delta.end.column); + if (action === "remove") { + removedFolds = this.getFoldsInRange(delta); + this.removeFolds(removedFolds); + + len = -len; + } + var foldLine = this.getFoldLine(firstRow); + if (foldLine) { + foldLine.addRemoveChars(firstRow, start.column, len); + } + } + + if (useWrapMode && this.$wrapData.length != this.doc.getLength()) { + console.error("doc.getLength() and $wrapData.length have to be the same!"); + } + this.$updating = false; + + if (useWrapMode) + this.$updateWrapData(firstRow, lastRow); + else + this.$updateRowLengthCache(firstRow, lastRow); + + return removedFolds; + }; + + this.$updateRowLengthCache = function(firstRow, lastRow, b) { + this.$rowLengthCache[firstRow] = null; + this.$rowLengthCache[lastRow] = null; + }; + + this.$updateWrapData = function(firstRow, lastRow) { + var lines = this.doc.getAllLines(); + var tabSize = this.getTabSize(); + var wrapData = this.$wrapData; + var wrapLimit = this.$wrapLimit; + var tokens; + var foldLine; + + var row = firstRow; + lastRow = Math.min(lastRow, lines.length - 1); + while (row <= lastRow) { + foldLine = this.getFoldLine(row, foldLine); + if (!foldLine) { + tokens = this.$getDisplayTokens(lines[row]); + wrapData[row] = this.$computeWrapSplits(tokens, wrapLimit, tabSize); + row ++; + } else { + tokens = []; + foldLine.walk(function(placeholder, row, column, lastColumn) { + var walkTokens; + if (placeholder != null) { + walkTokens = this.$getDisplayTokens( + placeholder, tokens.length); + walkTokens[0] = PLACEHOLDER_START; + for (var i = 1; i < walkTokens.length; i++) { + walkTokens[i] = PLACEHOLDER_BODY; + } + } else { + walkTokens = this.$getDisplayTokens( + lines[row].substring(lastColumn, column), + tokens.length); + } + tokens = tokens.concat(walkTokens); + }.bind(this), + foldLine.end.row, + lines[foldLine.end.row].length + 1 + ); + + wrapData[foldLine.start.row] = this.$computeWrapSplits(tokens, wrapLimit, tabSize); + row = foldLine.end.row + 1; + } + } + }; + var CHAR = 1, + CHAR_EXT = 2, + PLACEHOLDER_START = 3, + PLACEHOLDER_BODY = 4, + PUNCTUATION = 9, + SPACE = 10, + TAB = 11, + TAB_SPACE = 12; + + + this.$computeWrapSplits = function(tokens, wrapLimit, tabSize) { + if (tokens.length == 0) { + return []; + } + + var splits = []; + var displayLength = tokens.length; + var lastSplit = 0, lastDocSplit = 0; + + var isCode = this.$wrapAsCode; + + var indentedSoftWrap = this.$indentedSoftWrap; + var maxIndent = wrapLimit <= Math.max(2 * tabSize, 8) + || indentedSoftWrap === false ? 0 : Math.floor(wrapLimit / 2); + + function getWrapIndent() { + var indentation = 0; + if (maxIndent === 0) + return indentation; + if (indentedSoftWrap) { + for (var i = 0; i < tokens.length; i++) { + var token = tokens[i]; + if (token == SPACE) + indentation += 1; + else if (token == TAB) + indentation += tabSize; + else if (token == TAB_SPACE) + continue; + else + break; + } + } + if (isCode && indentedSoftWrap !== false) + indentation += tabSize; + return Math.min(indentation, maxIndent); + } + function addSplit(screenPos) { + var len = screenPos - lastSplit; + for (var i = lastSplit; i < screenPos; i++) { + var ch = tokens[i]; + if (ch === 12 || ch === 2) len -= 1; + } + + if (!splits.length) { + indent = getWrapIndent(); + splits.indent = indent; + } + lastDocSplit += len; + splits.push(lastDocSplit); + lastSplit = screenPos; + } + var indent = 0; + while (displayLength - lastSplit > wrapLimit - indent) { + var split = lastSplit + wrapLimit - indent; + if (tokens[split - 1] >= SPACE && tokens[split] >= SPACE) { + addSplit(split); + continue; + } + if (tokens[split] == PLACEHOLDER_START || tokens[split] == PLACEHOLDER_BODY) { + for (split; split != lastSplit - 1; split--) { + if (tokens[split] == PLACEHOLDER_START) { + break; + } + } + if (split > lastSplit) { + addSplit(split); + continue; + } + split = lastSplit + wrapLimit; + for (split; split < tokens.length; split++) { + if (tokens[split] != PLACEHOLDER_BODY) { + break; + } + } + if (split == tokens.length) { + break; // Breaks the while-loop. + } + addSplit(split); + continue; + } + var minSplit = Math.max(split - (wrapLimit -(wrapLimit>>2)), lastSplit - 1); + while (split > minSplit && tokens[split] < PLACEHOLDER_START) { + split --; + } + if (isCode) { + while (split > minSplit && tokens[split] < PLACEHOLDER_START) { + split --; + } + while (split > minSplit && tokens[split] == PUNCTUATION) { + split --; + } + } else { + while (split > minSplit && tokens[split] < SPACE) { + split --; + } + } + if (split > minSplit) { + addSplit(++split); + continue; + } + split = lastSplit + wrapLimit; + if (tokens[split] == CHAR_EXT) + split--; + addSplit(split - indent); + } + return splits; + }; + this.$getDisplayTokens = function(str, offset) { + var arr = []; + var tabSize; + offset = offset || 0; + + for (var i = 0; i < str.length; i++) { + var c = str.charCodeAt(i); + if (c == 9) { + tabSize = this.getScreenTabSize(arr.length + offset); + arr.push(TAB); + for (var n = 1; n < tabSize; n++) { + arr.push(TAB_SPACE); + } + } + else if (c == 32) { + arr.push(SPACE); + } else if((c > 39 && c < 48) || (c > 57 && c < 64)) { + arr.push(PUNCTUATION); + } + else if (c >= 0x1100 && isFullWidth(c)) { + arr.push(CHAR, CHAR_EXT); + } else { + arr.push(CHAR); + } + } + return arr; + }; + this.$getStringScreenWidth = function(str, maxScreenColumn, screenColumn) { + if (maxScreenColumn == 0) + return [0, 0]; + if (maxScreenColumn == null) + maxScreenColumn = Infinity; + screenColumn = screenColumn || 0; + + var c, column; + for (column = 0; column < str.length; column++) { + c = str.charCodeAt(column); + if (c == 9) { + screenColumn += this.getScreenTabSize(screenColumn); + } + else if (c >= 0x1100 && isFullWidth(c)) { + screenColumn += 2; + } else { + screenColumn += 1; + } + if (screenColumn > maxScreenColumn) { + break; + } + } + + return [screenColumn, column]; + }; + + this.lineWidgets = null; + this.getRowLength = function(row) { + var h = 1; + if (this.lineWidgets) + h += this.lineWidgets[row] && this.lineWidgets[row].rowCount || 0; + + if (!this.$useWrapMode || !this.$wrapData[row]) + return h; + else + return this.$wrapData[row].length + h; + }; + this.getRowLineCount = function(row) { + if (!this.$useWrapMode || !this.$wrapData[row]) { + return 1; + } else { + return this.$wrapData[row].length + 1; + } + }; + + this.getRowWrapIndent = function(screenRow) { + if (this.$useWrapMode) { + var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE); + var splits = this.$wrapData[pos.row]; + return splits.length && splits[0] < pos.column ? splits.indent : 0; + } else { + return 0; + } + }; + this.getScreenLastRowColumn = function(screenRow) { + var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE); + return this.documentToScreenColumn(pos.row, pos.column); + }; + this.getDocumentLastRowColumn = function(docRow, docColumn) { + var screenRow = this.documentToScreenRow(docRow, docColumn); + return this.getScreenLastRowColumn(screenRow); + }; + this.getDocumentLastRowColumnPosition = function(docRow, docColumn) { + var screenRow = this.documentToScreenRow(docRow, docColumn); + return this.screenToDocumentPosition(screenRow, Number.MAX_VALUE / 10); + }; + this.getRowSplitData = function(row) { + if (!this.$useWrapMode) { + return undefined; + } else { + return this.$wrapData[row]; + } + }; + this.getScreenTabSize = function(screenColumn) { + return this.$tabSize - (screenColumn % this.$tabSize | 0); + }; + + + this.screenToDocumentRow = function(screenRow, screenColumn) { + return this.screenToDocumentPosition(screenRow, screenColumn).row; + }; + + + this.screenToDocumentColumn = function(screenRow, screenColumn) { + return this.screenToDocumentPosition(screenRow, screenColumn).column; + }; + this.screenToDocumentPosition = function(screenRow, screenColumn, offsetX) { + if (screenRow < 0) + return {row: 0, column: 0}; + + var line; + var docRow = 0; + var docColumn = 0; + var column; + var row = 0; + var rowLength = 0; + + var rowCache = this.$screenRowCache; + var i = this.$getRowCacheIndex(rowCache, screenRow); + var l = rowCache.length; + if (l && i >= 0) { + var row = rowCache[i]; + var docRow = this.$docRowCache[i]; + var doCache = screenRow > rowCache[l - 1]; + } else { + var doCache = !l; + } + + var maxRow = this.getLength() - 1; + var foldLine = this.getNextFoldLine(docRow); + var foldStart = foldLine ? foldLine.start.row : Infinity; + + while (row <= screenRow) { + rowLength = this.getRowLength(docRow); + if (row + rowLength > screenRow || docRow >= maxRow) { + break; + } else { + row += rowLength; + docRow++; + if (docRow > foldStart) { + docRow = foldLine.end.row+1; + foldLine = this.getNextFoldLine(docRow, foldLine); + foldStart = foldLine ? foldLine.start.row : Infinity; + } + } + + if (doCache) { + this.$docRowCache.push(docRow); + this.$screenRowCache.push(row); + } + } + + if (foldLine && foldLine.start.row <= docRow) { + line = this.getFoldDisplayLine(foldLine); + docRow = foldLine.start.row; + } else if (row + rowLength <= screenRow || docRow > maxRow) { + return { + row: maxRow, + column: this.getLine(maxRow).length + }; + } else { + line = this.getLine(docRow); + foldLine = null; + } + var wrapIndent = 0, splitIndex = Math.floor(screenRow - row); + if (this.$useWrapMode) { + var splits = this.$wrapData[docRow]; + if (splits) { + column = splits[splitIndex]; + if(splitIndex > 0 && splits.length) { + wrapIndent = splits.indent; + docColumn = splits[splitIndex - 1] || splits[splits.length - 1]; + line = line.substring(docColumn); + } + } + } + + if (offsetX !== undefined && this.$bidiHandler.isBidiRow(row + splitIndex, docRow, splitIndex)) + screenColumn = this.$bidiHandler.offsetToCol(offsetX); + + docColumn += this.$getStringScreenWidth(line, screenColumn - wrapIndent)[1]; + if (this.$useWrapMode && docColumn >= column) + docColumn = column - 1; + + if (foldLine) + return foldLine.idxToPosition(docColumn); + + return {row: docRow, column: docColumn}; + }; + this.documentToScreenPosition = function(docRow, docColumn) { + if (typeof docColumn === "undefined") + var pos = this.$clipPositionToDocument(docRow.row, docRow.column); + else + pos = this.$clipPositionToDocument(docRow, docColumn); + + docRow = pos.row; + docColumn = pos.column; + + var screenRow = 0; + var foldStartRow = null; + var fold = null; + fold = this.getFoldAt(docRow, docColumn, 1); + if (fold) { + docRow = fold.start.row; + docColumn = fold.start.column; + } + + var rowEnd, row = 0; + + + var rowCache = this.$docRowCache; + var i = this.$getRowCacheIndex(rowCache, docRow); + var l = rowCache.length; + if (l && i >= 0) { + var row = rowCache[i]; + var screenRow = this.$screenRowCache[i]; + var doCache = docRow > rowCache[l - 1]; + } else { + var doCache = !l; + } + + var foldLine = this.getNextFoldLine(row); + var foldStart = foldLine ?foldLine.start.row :Infinity; + + while (row < docRow) { + if (row >= foldStart) { + rowEnd = foldLine.end.row + 1; + if (rowEnd > docRow) + break; + foldLine = this.getNextFoldLine(rowEnd, foldLine); + foldStart = foldLine ?foldLine.start.row :Infinity; + } + else { + rowEnd = row + 1; + } + + screenRow += this.getRowLength(row); + row = rowEnd; + + if (doCache) { + this.$docRowCache.push(row); + this.$screenRowCache.push(screenRow); + } + } + var textLine = ""; + if (foldLine && row >= foldStart) { + textLine = this.getFoldDisplayLine(foldLine, docRow, docColumn); + foldStartRow = foldLine.start.row; + } else { + textLine = this.getLine(docRow).substring(0, docColumn); + foldStartRow = docRow; + } + var wrapIndent = 0; + if (this.$useWrapMode) { + var wrapRow = this.$wrapData[foldStartRow]; + if (wrapRow) { + var screenRowOffset = 0; + while (textLine.length >= wrapRow[screenRowOffset]) { + screenRow ++; + screenRowOffset++; + } + textLine = textLine.substring( + wrapRow[screenRowOffset - 1] || 0, textLine.length + ); + wrapIndent = screenRowOffset > 0 ? wrapRow.indent : 0; + } + } + + if (this.lineWidgets && this.lineWidgets[row] && this.lineWidgets[row].rowsAbove) + screenRow += this.lineWidgets[row].rowsAbove; + + return { + row: screenRow, + column: wrapIndent + this.$getStringScreenWidth(textLine)[0] + }; + }; + this.documentToScreenColumn = function(row, docColumn) { + return this.documentToScreenPosition(row, docColumn).column; + }; + this.documentToScreenRow = function(docRow, docColumn) { + return this.documentToScreenPosition(docRow, docColumn).row; + }; + this.getScreenLength = function() { + var screenRows = 0; + var fold = null; + if (!this.$useWrapMode) { + screenRows = this.getLength(); + var foldData = this.$foldData; + for (var i = 0; i < foldData.length; i++) { + fold = foldData[i]; + screenRows -= fold.end.row - fold.start.row; + } + } else { + var lastRow = this.$wrapData.length; + var row = 0, i = 0; + var fold = this.$foldData[i++]; + var foldStart = fold ? fold.start.row :Infinity; + + while (row < lastRow) { + var splits = this.$wrapData[row]; + screenRows += splits ? splits.length + 1 : 1; + row ++; + if (row > foldStart) { + row = fold.end.row+1; + fold = this.$foldData[i++]; + foldStart = fold ?fold.start.row :Infinity; + } + } + } + if (this.lineWidgets) + screenRows += this.$getWidgetScreenLength(); + + return screenRows; + }; + this.$setFontMetrics = function(fm) { + if (!this.$enableVarChar) return; + this.$getStringScreenWidth = function(str, maxScreenColumn, screenColumn) { + if (maxScreenColumn === 0) + return [0, 0]; + if (!maxScreenColumn) + maxScreenColumn = Infinity; + screenColumn = screenColumn || 0; + + var c, column; + for (column = 0; column < str.length; column++) { + c = str.charAt(column); + if (c === "\t") { + screenColumn += this.getScreenTabSize(screenColumn); + } else { + screenColumn += fm.getCharacterWidth(c); + } + if (screenColumn > maxScreenColumn) { + break; + } + } + + return [screenColumn, column]; + }; + }; + + this.destroy = function() { + if (this.bgTokenizer) { + this.bgTokenizer.setDocument(null); + this.bgTokenizer = null; + } + this.$stopWorker(); + this.removeAllListeners(); + if (this.doc) { + this.doc.off("change", this.$onChange); + } + this.selection.detach(); + }; + + this.isFullWidth = isFullWidth; + function isFullWidth(c) { + if (c < 0x1100) + return false; + return c >= 0x1100 && c <= 0x115F || + c >= 0x11A3 && c <= 0x11A7 || + c >= 0x11FA && c <= 0x11FF || + c >= 0x2329 && c <= 0x232A || + c >= 0x2E80 && c <= 0x2E99 || + c >= 0x2E9B && c <= 0x2EF3 || + c >= 0x2F00 && c <= 0x2FD5 || + c >= 0x2FF0 && c <= 0x2FFB || + c >= 0x3000 && c <= 0x303E || + c >= 0x3041 && c <= 0x3096 || + c >= 0x3099 && c <= 0x30FF || + c >= 0x3105 && c <= 0x312D || + c >= 0x3131 && c <= 0x318E || + c >= 0x3190 && c <= 0x31BA || + c >= 0x31C0 && c <= 0x31E3 || + c >= 0x31F0 && c <= 0x321E || + c >= 0x3220 && c <= 0x3247 || + c >= 0x3250 && c <= 0x32FE || + c >= 0x3300 && c <= 0x4DBF || + c >= 0x4E00 && c <= 0xA48C || + c >= 0xA490 && c <= 0xA4C6 || + c >= 0xA960 && c <= 0xA97C || + c >= 0xAC00 && c <= 0xD7A3 || + c >= 0xD7B0 && c <= 0xD7C6 || + c >= 0xD7CB && c <= 0xD7FB || + c >= 0xF900 && c <= 0xFAFF || + c >= 0xFE10 && c <= 0xFE19 || + c >= 0xFE30 && c <= 0xFE52 || + c >= 0xFE54 && c <= 0xFE66 || + c >= 0xFE68 && c <= 0xFE6B || + c >= 0xFF01 && c <= 0xFF60 || + c >= 0xFFE0 && c <= 0xFFE6; + } + +}).call(EditSession.prototype); + +require("./edit_session/folding").Folding.call(EditSession.prototype); +require("./edit_session/bracket_match").BracketMatch.call(EditSession.prototype); + + +config.defineOptions(EditSession.prototype, "session", { + wrap: { + set: function(value) { + if (!value || value == "off") + value = false; + else if (value == "free") + value = true; + else if (value == "printMargin") + value = -1; + else if (typeof value == "string") + value = parseInt(value, 10) || false; + + if (this.$wrap == value) + return; + this.$wrap = value; + if (!value) { + this.setUseWrapMode(false); + } else { + var col = typeof value == "number" ? value : null; + this.setWrapLimitRange(col, col); + this.setUseWrapMode(true); + } + }, + get: function() { + if (this.getUseWrapMode()) { + if (this.$wrap == -1) + return "printMargin"; + if (!this.getWrapLimitRange().min) + return "free"; + return this.$wrap; + } + return "off"; + }, + handlesSet: true + }, + wrapMethod: { + set: function(val) { + val = val == "auto" + ? this.$mode.type != "text" + : val != "text"; + if (val != this.$wrapAsCode) { + this.$wrapAsCode = val; + if (this.$useWrapMode) { + this.$useWrapMode = false; + this.setUseWrapMode(true); + } + } + }, + initialValue: "auto" + }, + indentedSoftWrap: { + set: function() { + if (this.$useWrapMode) { + this.$useWrapMode = false; + this.setUseWrapMode(true); + } + }, + initialValue: true + }, + firstLineNumber: { + set: function() {this._signal("changeBreakpoint");}, + initialValue: 1 + }, + useWorker: { + set: function(useWorker) { + this.$useWorker = useWorker; + + this.$stopWorker(); + if (useWorker) + this.$startWorker(); + }, + initialValue: true + }, + useSoftTabs: {initialValue: true}, + tabSize: { + set: function(tabSize) { + tabSize = parseInt(tabSize); + if (tabSize > 0 && this.$tabSize !== tabSize) { + this.$modified = true; + this.$rowLengthCache = []; + this.$tabSize = tabSize; + this._signal("changeTabSize"); + } + }, + initialValue: 4, + handlesSet: true + }, + navigateWithinSoftTabs: {initialValue: false}, + foldStyle: { + set: function(val) {this.setFoldStyle(val);}, + handlesSet: true + }, + overwrite: { + set: function(val) {this._signal("changeOverwrite");}, + initialValue: false + }, + newLineMode: { + set: function(val) {this.doc.setNewLineMode(val);}, + get: function() {return this.doc.getNewLineMode();}, + handlesSet: true + }, + mode: { + set: function(val) { this.setMode(val); }, + get: function() { return this.$modeId; }, + handlesSet: true + } +}); + +exports.EditSession = EditSession; +}); + +ace.define("ace/search",["require","exports","module","ace/lib/lang","ace/lib/oop","ace/range"], function(require, exports, module) { +"use strict"; + +var lang = require("./lib/lang"); +var oop = require("./lib/oop"); +var Range = require("./range").Range; + +var Search = function() { + this.$options = {}; +}; + +(function() { + this.set = function(options) { + oop.mixin(this.$options, options); + return this; + }; + this.getOptions = function() { + return lang.copyObject(this.$options); + }; + this.setOptions = function(options) { + this.$options = options; + }; + this.find = function(session) { + var options = this.$options; + var iterator = this.$matchIterator(session, options); + if (!iterator) + return false; + + var firstRange = null; + iterator.forEach(function(sr, sc, er, ec) { + firstRange = new Range(sr, sc, er, ec); + if (sc == ec && options.start && options.start.start + && options.skipCurrent != false && firstRange.isEqual(options.start) + ) { + firstRange = null; + return false; + } + + return true; + }); + + return firstRange; + }; + this.findAll = function(session) { + var options = this.$options; + if (!options.needle) + return []; + this.$assembleRegExp(options); + + var range = options.range; + var lines = range + ? session.getLines(range.start.row, range.end.row) + : session.doc.getAllLines(); + + var ranges = []; + var re = options.re; + if (options.$isMultiLine) { + var len = re.length; + var maxRow = lines.length - len; + var prevRange; + outer: for (var row = re.offset || 0; row <= maxRow; row++) { + for (var j = 0; j < len; j++) + if (lines[row + j].search(re[j]) == -1) + continue outer; + + var startLine = lines[row]; + var line = lines[row + len - 1]; + var startIndex = startLine.length - startLine.match(re[0])[0].length; + var endIndex = line.match(re[len - 1])[0].length; + + if (prevRange && prevRange.end.row === row && + prevRange.end.column > startIndex + ) { + continue; + } + ranges.push(prevRange = new Range( + row, startIndex, row + len - 1, endIndex + )); + if (len > 2) + row = row + len - 2; + } + } else { + for (var i = 0; i < lines.length; i++) { + var matches = lang.getMatchOffsets(lines[i], re); + for (var j = 0; j < matches.length; j++) { + var match = matches[j]; + ranges.push(new Range(i, match.offset, i, match.offset + match.length)); + } + } + } + + if (range) { + var startColumn = range.start.column; + var endColumn = range.start.column; + var i = 0, j = ranges.length - 1; + while (i < j && ranges[i].start.column < startColumn && ranges[i].start.row == range.start.row) + i++; + + while (i < j && ranges[j].end.column > endColumn && ranges[j].end.row == range.end.row) + j--; + + ranges = ranges.slice(i, j + 1); + for (i = 0, j = ranges.length; i < j; i++) { + ranges[i].start.row += range.start.row; + ranges[i].end.row += range.start.row; + } + } + + return ranges; + }; + this.replace = function(input, replacement) { + var options = this.$options; + + var re = this.$assembleRegExp(options); + if (options.$isMultiLine) + return replacement; + + if (!re) + return; + + var match = re.exec(input); + if (!match || match[0].length != input.length) + return null; + + replacement = input.replace(re, replacement); + if (options.preserveCase) { + replacement = replacement.split(""); + for (var i = Math.min(input.length, input.length); i--; ) { + var ch = input[i]; + if (ch && ch.toLowerCase() != ch) + replacement[i] = replacement[i].toUpperCase(); + else + replacement[i] = replacement[i].toLowerCase(); + } + replacement = replacement.join(""); + } + + return replacement; + }; + + this.$assembleRegExp = function(options, $disableFakeMultiline) { + if (options.needle instanceof RegExp) + return options.re = options.needle; + + var needle = options.needle; + + if (!options.needle) + return options.re = false; + + if (!options.regExp) + needle = lang.escapeRegExp(needle); + + if (options.wholeWord) + needle = addWordBoundary(needle, options); + + var modifier = options.caseSensitive ? "gm" : "gmi"; + + options.$isMultiLine = !$disableFakeMultiline && /[\n\r]/.test(needle); + if (options.$isMultiLine) + return options.re = this.$assembleMultilineRegExp(needle, modifier); + + try { + var re = new RegExp(needle, modifier); + } catch(e) { + re = false; + } + return options.re = re; + }; + + this.$assembleMultilineRegExp = function(needle, modifier) { + var parts = needle.replace(/\r\n|\r|\n/g, "$\n^").split("\n"); + var re = []; + for (var i = 0; i < parts.length; i++) try { + re.push(new RegExp(parts[i], modifier)); + } catch(e) { + return false; + } + return re; + }; + + this.$matchIterator = function(session, options) { + var re = this.$assembleRegExp(options); + if (!re) + return false; + var backwards = options.backwards == true; + var skipCurrent = options.skipCurrent != false; + + var range = options.range; + var start = options.start; + if (!start) + start = range ? range[backwards ? "end" : "start"] : session.selection.getRange(); + + if (start.start) + start = start[skipCurrent != backwards ? "end" : "start"]; + + var firstRow = range ? range.start.row : 0; + var lastRow = range ? range.end.row : session.getLength() - 1; + + if (backwards) { + var forEach = function(callback) { + var row = start.row; + if (forEachInLine(row, start.column, callback)) + return; + for (row--; row >= firstRow; row--) + if (forEachInLine(row, Number.MAX_VALUE, callback)) + return; + if (options.wrap == false) + return; + for (row = lastRow, firstRow = start.row; row >= firstRow; row--) + if (forEachInLine(row, Number.MAX_VALUE, callback)) + return; + }; + } + else { + var forEach = function(callback) { + var row = start.row; + if (forEachInLine(row, start.column, callback)) + return; + for (row = row + 1; row <= lastRow; row++) + if (forEachInLine(row, 0, callback)) + return; + if (options.wrap == false) + return; + for (row = firstRow, lastRow = start.row; row <= lastRow; row++) + if (forEachInLine(row, 0, callback)) + return; + }; + } + + if (options.$isMultiLine) { + var len = re.length; + var forEachInLine = function(row, offset, callback) { + var startRow = backwards ? row - len + 1 : row; + if (startRow < 0 || startRow + len > session.getLength()) return; + var line = session.getLine(startRow); + var startIndex = line.search(re[0]); + if (!backwards && startIndex < offset || startIndex === -1) return; + for (var i = 1; i < len; i++) { + line = session.getLine(startRow + i); + if (line.search(re[i]) == -1) + return; + } + var endIndex = line.match(re[len - 1])[0].length; + if (backwards && endIndex > offset) return; + if (callback(startRow, startIndex, startRow + len - 1, endIndex)) + return true; + }; + } + else if (backwards) { + var forEachInLine = function(row, endIndex, callback) { + var line = session.getLine(row); + var matches = []; + var m, last = 0; + re.lastIndex = 0; + while((m = re.exec(line))) { + var length = m[0].length; + last = m.index; + if (!length) { + if (last >= line.length) break; + re.lastIndex = last += 1; + } + if (m.index + length > endIndex) + break; + matches.push(m.index, length); + } + for (var i = matches.length - 1; i >= 0; i -= 2) { + var column = matches[i - 1]; + var length = matches[i]; + if (callback(row, column, row, column + length)) + return true; + } + }; + } + else { + var forEachInLine = function(row, startIndex, callback) { + var line = session.getLine(row); + var last; + var m; + re.lastIndex = startIndex; + while((m = re.exec(line))) { + var length = m[0].length; + last = m.index; + if (callback(row, last, row,last + length)) + return true; + if (!length) { + re.lastIndex = last += 1; + if (last >= line.length) return false; + } + } + }; + } + return {forEach: forEach}; + }; + +}).call(Search.prototype); + +function addWordBoundary(needle, options) { + function wordBoundary(c) { + if (/\w/.test(c) || options.regExp) return "\\b"; + return ""; + } + return wordBoundary(needle[0]) + needle + + wordBoundary(needle[needle.length - 1]); +} + +exports.Search = Search; +}); + +ace.define("ace/keyboard/hash_handler",["require","exports","module","ace/lib/keys","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var keyUtil = require("../lib/keys"); +var useragent = require("../lib/useragent"); +var KEY_MODS = keyUtil.KEY_MODS; + +function HashHandler(config, platform) { + this.platform = platform || (useragent.isMac ? "mac" : "win"); + this.commands = {}; + this.commandKeyBinding = {}; + this.addCommands(config); + this.$singleCommand = true; +} + +function MultiHashHandler(config, platform) { + HashHandler.call(this, config, platform); + this.$singleCommand = false; +} + +MultiHashHandler.prototype = HashHandler.prototype; + +(function() { + + + this.addCommand = function(command) { + if (this.commands[command.name]) + this.removeCommand(command); + + this.commands[command.name] = command; + + if (command.bindKey) + this._buildKeyHash(command); + }; + + this.removeCommand = function(command, keepCommand) { + var name = command && (typeof command === 'string' ? command : command.name); + command = this.commands[name]; + if (!keepCommand) + delete this.commands[name]; + var ckb = this.commandKeyBinding; + for (var keyId in ckb) { + var cmdGroup = ckb[keyId]; + if (cmdGroup == command) { + delete ckb[keyId]; + } else if (Array.isArray(cmdGroup)) { + var i = cmdGroup.indexOf(command); + if (i != -1) { + cmdGroup.splice(i, 1); + if (cmdGroup.length == 1) + ckb[keyId] = cmdGroup[0]; + } + } + } + }; + + this.bindKey = function(key, command, position) { + if (typeof key == "object" && key) { + if (position == undefined) + position = key.position; + key = key[this.platform]; + } + if (!key) + return; + if (typeof command == "function") + return this.addCommand({exec: command, bindKey: key, name: command.name || key}); + + key.split("|").forEach(function(keyPart) { + var chain = ""; + if (keyPart.indexOf(" ") != -1) { + var parts = keyPart.split(/\s+/); + keyPart = parts.pop(); + parts.forEach(function(keyPart) { + var binding = this.parseKeys(keyPart); + var id = KEY_MODS[binding.hashId] + binding.key; + chain += (chain ? " " : "") + id; + this._addCommandToBinding(chain, "chainKeys"); + }, this); + chain += " "; + } + var binding = this.parseKeys(keyPart); + var id = KEY_MODS[binding.hashId] + binding.key; + this._addCommandToBinding(chain + id, command, position); + }, this); + }; + + function getPosition(command) { + return typeof command == "object" && command.bindKey + && command.bindKey.position + || (command.isDefault ? -100 : 0); + } + this._addCommandToBinding = function(keyId, command, position) { + var ckb = this.commandKeyBinding, i; + if (!command) { + delete ckb[keyId]; + } else if (!ckb[keyId] || this.$singleCommand) { + ckb[keyId] = command; + } else { + if (!Array.isArray(ckb[keyId])) { + ckb[keyId] = [ckb[keyId]]; + } else if ((i = ckb[keyId].indexOf(command)) != -1) { + ckb[keyId].splice(i, 1); + } + + if (typeof position != "number") { + position = getPosition(command); + } + + var commands = ckb[keyId]; + for (i = 0; i < commands.length; i++) { + var other = commands[i]; + var otherPos = getPosition(other); + if (otherPos > position) + break; + } + commands.splice(i, 0, command); + } + }; + + this.addCommands = function(commands) { + commands && Object.keys(commands).forEach(function(name) { + var command = commands[name]; + if (!command) + return; + + if (typeof command === "string") + return this.bindKey(command, name); + + if (typeof command === "function") + command = { exec: command }; + + if (typeof command !== "object") + return; + + if (!command.name) + command.name = name; + + this.addCommand(command); + }, this); + }; + + this.removeCommands = function(commands) { + Object.keys(commands).forEach(function(name) { + this.removeCommand(commands[name]); + }, this); + }; + + this.bindKeys = function(keyList) { + Object.keys(keyList).forEach(function(key) { + this.bindKey(key, keyList[key]); + }, this); + }; + + this._buildKeyHash = function(command) { + this.bindKey(command.bindKey, command); + }; + this.parseKeys = function(keys) { + var parts = keys.toLowerCase().split(/[\-\+]([\-\+])?/).filter(function(x){return x;}); + var key = parts.pop(); + + var keyCode = keyUtil[key]; + if (keyUtil.FUNCTION_KEYS[keyCode]) + key = keyUtil.FUNCTION_KEYS[keyCode].toLowerCase(); + else if (!parts.length) + return {key: key, hashId: -1}; + else if (parts.length == 1 && parts[0] == "shift") + return {key: key.toUpperCase(), hashId: -1}; + + var hashId = 0; + for (var i = parts.length; i--;) { + var modifier = keyUtil.KEY_MODS[parts[i]]; + if (modifier == null) { + if (typeof console != "undefined") + console.error("invalid modifier " + parts[i] + " in " + keys); + return false; + } + hashId |= modifier; + } + return {key: key, hashId: hashId}; + }; + + this.findKeyCommand = function findKeyCommand(hashId, keyString) { + var key = KEY_MODS[hashId] + keyString; + return this.commandKeyBinding[key]; + }; + + this.handleKeyboard = function(data, hashId, keyString, keyCode) { + if (keyCode < 0) return; + var key = KEY_MODS[hashId] + keyString; + var command = this.commandKeyBinding[key]; + if (data.$keyChain) { + data.$keyChain += " " + key; + command = this.commandKeyBinding[data.$keyChain] || command; + } + + if (command) { + if (command == "chainKeys" || command[command.length - 1] == "chainKeys") { + data.$keyChain = data.$keyChain || key; + return {command: "null"}; + } + } + + if (data.$keyChain) { + if ((!hashId || hashId == 4) && keyString.length == 1) + data.$keyChain = data.$keyChain.slice(0, -key.length - 1); // wait for input + else if (hashId == -1 || keyCode > 0) + data.$keyChain = ""; // reset keyChain + } + return {command: command}; + }; + + this.getStatusText = function(editor, data) { + return data.$keyChain || ""; + }; + +}).call(HashHandler.prototype); + +exports.HashHandler = HashHandler; +exports.MultiHashHandler = MultiHashHandler; +}); + +ace.define("ace/commands/command_manager",["require","exports","module","ace/lib/oop","ace/keyboard/hash_handler","ace/lib/event_emitter"], function(require, exports, module) { +"use strict"; + +var oop = require("../lib/oop"); +var MultiHashHandler = require("../keyboard/hash_handler").MultiHashHandler; +var EventEmitter = require("../lib/event_emitter").EventEmitter; + +var CommandManager = function(platform, commands) { + MultiHashHandler.call(this, commands, platform); + this.byName = this.commands; + this.setDefaultHandler("exec", function(e) { + return e.command.exec(e.editor, e.args || {}); + }); +}; + +oop.inherits(CommandManager, MultiHashHandler); + +(function() { + + oop.implement(this, EventEmitter); + + this.exec = function(command, editor, args) { + if (Array.isArray(command)) { + for (var i = command.length; i--; ) { + if (this.exec(command[i], editor, args)) return true; + } + return false; + } + + if (typeof command === "string") + command = this.commands[command]; + + if (!command) + return false; + + if (editor && editor.$readOnly && !command.readOnly) + return false; + + if (this.$checkCommandState != false && command.isAvailable && !command.isAvailable(editor)) + return false; + + var e = {editor: editor, command: command, args: args}; + e.returnValue = this._emit("exec", e); + this._signal("afterExec", e); + + return e.returnValue === false ? false : true; + }; + + this.toggleRecording = function(editor) { + if (this.$inReplay) + return; + + editor && editor._emit("changeStatus"); + if (this.recording) { + this.macro.pop(); + this.off("exec", this.$addCommandToMacro); + + if (!this.macro.length) + this.macro = this.oldMacro; + + return this.recording = false; + } + if (!this.$addCommandToMacro) { + this.$addCommandToMacro = function(e) { + this.macro.push([e.command, e.args]); + }.bind(this); + } + + this.oldMacro = this.macro; + this.macro = []; + this.on("exec", this.$addCommandToMacro); + return this.recording = true; + }; + + this.replay = function(editor) { + if (this.$inReplay || !this.macro) + return; + + if (this.recording) + return this.toggleRecording(editor); + + try { + this.$inReplay = true; + this.macro.forEach(function(x) { + if (typeof x == "string") + this.exec(x, editor); + else + this.exec(x[0], editor, x[1]); + }, this); + } finally { + this.$inReplay = false; + } + }; + + this.trimMacro = function(m) { + return m.map(function(x){ + if (typeof x[0] != "string") + x[0] = x[0].name; + if (!x[1]) + x = x[0]; + return x; + }); + }; + +}).call(CommandManager.prototype); + +exports.CommandManager = CommandManager; + +}); + +ace.define("ace/commands/default_commands",["require","exports","module","ace/lib/lang","ace/config","ace/range"], function(require, exports, module) { +"use strict"; + +var lang = require("../lib/lang"); +var config = require("../config"); +var Range = require("../range").Range; + +function bindKey(win, mac) { + return {win: win, mac: mac}; +} +exports.commands = [{ + name: "showSettingsMenu", + description: "Show settings menu", + bindKey: bindKey("Ctrl-,", "Command-,"), + exec: function(editor) { + config.loadModule("ace/ext/settings_menu", function(module) { + module.init(editor); + editor.showSettingsMenu(); + }); + }, + readOnly: true +}, { + name: "goToNextError", + description: "Go to next error", + bindKey: bindKey("Alt-E", "F4"), + exec: function(editor) { + config.loadModule("./ext/error_marker", function(module) { + module.showErrorMarker(editor, 1); + }); + }, + scrollIntoView: "animate", + readOnly: true +}, { + name: "goToPreviousError", + description: "Go to previous error", + bindKey: bindKey("Alt-Shift-E", "Shift-F4"), + exec: function(editor) { + config.loadModule("./ext/error_marker", function(module) { + module.showErrorMarker(editor, -1); + }); + }, + scrollIntoView: "animate", + readOnly: true +}, { + name: "selectall", + description: "Select all", + bindKey: bindKey("Ctrl-A", "Command-A"), + exec: function(editor) { editor.selectAll(); }, + readOnly: true +}, { + name: "centerselection", + description: "Center selection", + bindKey: bindKey(null, "Ctrl-L"), + exec: function(editor) { editor.centerSelection(); }, + readOnly: true +}, { + name: "gotoline", + description: "Go to line...", + bindKey: bindKey("Ctrl-L", "Command-L"), + exec: function(editor, line) { + if (typeof line === "number" && !isNaN(line)) + editor.gotoLine(line); + editor.prompt({ $type: "gotoLine" }); + }, + readOnly: true +}, { + name: "fold", + bindKey: bindKey("Alt-L|Ctrl-F1", "Command-Alt-L|Command-F1"), + exec: function(editor) { editor.session.toggleFold(false); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "unfold", + bindKey: bindKey("Alt-Shift-L|Ctrl-Shift-F1", "Command-Alt-Shift-L|Command-Shift-F1"), + exec: function(editor) { editor.session.toggleFold(true); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "toggleFoldWidget", + description: "Toggle fold widget", + bindKey: bindKey("F2", "F2"), + exec: function(editor) { editor.session.toggleFoldWidget(); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "toggleParentFoldWidget", + description: "Toggle parent fold widget", + bindKey: bindKey("Alt-F2", "Alt-F2"), + exec: function(editor) { editor.session.toggleFoldWidget(true); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "foldall", + description: "Fold all", + bindKey: bindKey(null, "Ctrl-Command-Option-0"), + exec: function(editor) { editor.session.foldAll(); }, + scrollIntoView: "center", + readOnly: true +}, { + name: "foldAllComments", + description: "Fold all comments", + bindKey: bindKey(null, "Ctrl-Command-Option-0"), + exec: function(editor) { editor.session.foldAllComments(); }, + scrollIntoView: "center", + readOnly: true +}, { + name: "foldOther", + description: "Fold other", + bindKey: bindKey("Alt-0", "Command-Option-0"), + exec: function(editor) { + editor.session.foldAll(); + editor.session.unfold(editor.selection.getAllRanges()); + }, + scrollIntoView: "center", + readOnly: true +}, { + name: "unfoldall", + description: "Unfold all", + bindKey: bindKey("Alt-Shift-0", "Command-Option-Shift-0"), + exec: function(editor) { editor.session.unfold(); }, + scrollIntoView: "center", + readOnly: true +}, { + name: "findnext", + description: "Find next", + bindKey: bindKey("Ctrl-K", "Command-G"), + exec: function(editor) { editor.findNext(); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "findprevious", + description: "Find previous", + bindKey: bindKey("Ctrl-Shift-K", "Command-Shift-G"), + exec: function(editor) { editor.findPrevious(); }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: true +}, { + name: "selectOrFindNext", + description: "Select or find next", + bindKey: bindKey("Alt-K", "Ctrl-G"), + exec: function(editor) { + if (editor.selection.isEmpty()) + editor.selection.selectWord(); + else + editor.findNext(); + }, + readOnly: true +}, { + name: "selectOrFindPrevious", + description: "Select or find previous", + bindKey: bindKey("Alt-Shift-K", "Ctrl-Shift-G"), + exec: function(editor) { + if (editor.selection.isEmpty()) + editor.selection.selectWord(); + else + editor.findPrevious(); + }, + readOnly: true +}, { + name: "find", + description: "Find", + bindKey: bindKey("Ctrl-F", "Command-F"), + exec: function(editor) { + config.loadModule("ace/ext/searchbox", function(e) {e.Search(editor);}); + }, + readOnly: true +}, { + name: "overwrite", + description: "Overwrite", + bindKey: "Insert", + exec: function(editor) { editor.toggleOverwrite(); }, + readOnly: true +}, { + name: "selecttostart", + description: "Select to start", + bindKey: bindKey("Ctrl-Shift-Home", "Command-Shift-Home|Command-Shift-Up"), + exec: function(editor) { editor.getSelection().selectFileStart(); }, + multiSelectAction: "forEach", + readOnly: true, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" +}, { + name: "gotostart", + description: "Go to start", + bindKey: bindKey("Ctrl-Home", "Command-Home|Command-Up"), + exec: function(editor) { editor.navigateFileStart(); }, + multiSelectAction: "forEach", + readOnly: true, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" +}, { + name: "selectup", + description: "Select up", + bindKey: bindKey("Shift-Up", "Shift-Up|Ctrl-Shift-P"), + exec: function(editor) { editor.getSelection().selectUp(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "golineup", + description: "Go line up", + bindKey: bindKey("Up", "Up|Ctrl-P"), + exec: function(editor, args) { editor.navigateUp(args.times); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selecttoend", + description: "Select to end", + bindKey: bindKey("Ctrl-Shift-End", "Command-Shift-End|Command-Shift-Down"), + exec: function(editor) { editor.getSelection().selectFileEnd(); }, + multiSelectAction: "forEach", + readOnly: true, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" +}, { + name: "gotoend", + description: "Go to end", + bindKey: bindKey("Ctrl-End", "Command-End|Command-Down"), + exec: function(editor) { editor.navigateFileEnd(); }, + multiSelectAction: "forEach", + readOnly: true, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" +}, { + name: "selectdown", + description: "Select down", + bindKey: bindKey("Shift-Down", "Shift-Down|Ctrl-Shift-N"), + exec: function(editor) { editor.getSelection().selectDown(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "golinedown", + description: "Go line down", + bindKey: bindKey("Down", "Down|Ctrl-N"), + exec: function(editor, args) { editor.navigateDown(args.times); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectwordleft", + description: "Select word left", + bindKey: bindKey("Ctrl-Shift-Left", "Option-Shift-Left"), + exec: function(editor) { editor.getSelection().selectWordLeft(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotowordleft", + description: "Go to word left", + bindKey: bindKey("Ctrl-Left", "Option-Left"), + exec: function(editor) { editor.navigateWordLeft(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selecttolinestart", + description: "Select to line start", + bindKey: bindKey("Alt-Shift-Left", "Command-Shift-Left|Ctrl-Shift-A"), + exec: function(editor) { editor.getSelection().selectLineStart(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotolinestart", + description: "Go to line start", + bindKey: bindKey("Alt-Left|Home", "Command-Left|Home|Ctrl-A"), + exec: function(editor) { editor.navigateLineStart(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectleft", + description: "Select left", + bindKey: bindKey("Shift-Left", "Shift-Left|Ctrl-Shift-B"), + exec: function(editor) { editor.getSelection().selectLeft(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotoleft", + description: "Go to left", + bindKey: bindKey("Left", "Left|Ctrl-B"), + exec: function(editor, args) { editor.navigateLeft(args.times); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectwordright", + description: "Select word right", + bindKey: bindKey("Ctrl-Shift-Right", "Option-Shift-Right"), + exec: function(editor) { editor.getSelection().selectWordRight(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotowordright", + description: "Go to word right", + bindKey: bindKey("Ctrl-Right", "Option-Right"), + exec: function(editor) { editor.navigateWordRight(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selecttolineend", + description: "Select to line end", + bindKey: bindKey("Alt-Shift-Right", "Command-Shift-Right|Shift-End|Ctrl-Shift-E"), + exec: function(editor) { editor.getSelection().selectLineEnd(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotolineend", + description: "Go to line end", + bindKey: bindKey("Alt-Right|End", "Command-Right|End|Ctrl-E"), + exec: function(editor) { editor.navigateLineEnd(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectright", + description: "Select right", + bindKey: bindKey("Shift-Right", "Shift-Right"), + exec: function(editor) { editor.getSelection().selectRight(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "gotoright", + description: "Go to right", + bindKey: bindKey("Right", "Right|Ctrl-F"), + exec: function(editor, args) { editor.navigateRight(args.times); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectpagedown", + description: "Select page down", + bindKey: "Shift-PageDown", + exec: function(editor) { editor.selectPageDown(); }, + readOnly: true +}, { + name: "pagedown", + description: "Page down", + bindKey: bindKey(null, "Option-PageDown"), + exec: function(editor) { editor.scrollPageDown(); }, + readOnly: true +}, { + name: "gotopagedown", + description: "Go to page down", + bindKey: bindKey("PageDown", "PageDown|Ctrl-V"), + exec: function(editor) { editor.gotoPageDown(); }, + readOnly: true +}, { + name: "selectpageup", + description: "Select page up", + bindKey: "Shift-PageUp", + exec: function(editor) { editor.selectPageUp(); }, + readOnly: true +}, { + name: "pageup", + description: "Page up", + bindKey: bindKey(null, "Option-PageUp"), + exec: function(editor) { editor.scrollPageUp(); }, + readOnly: true +}, { + name: "gotopageup", + description: "Go to page up", + bindKey: "PageUp", + exec: function(editor) { editor.gotoPageUp(); }, + readOnly: true +}, { + name: "scrollup", + description: "Scroll up", + bindKey: bindKey("Ctrl-Up", null), + exec: function(e) { e.renderer.scrollBy(0, -2 * e.renderer.layerConfig.lineHeight); }, + readOnly: true +}, { + name: "scrolldown", + description: "Scroll down", + bindKey: bindKey("Ctrl-Down", null), + exec: function(e) { e.renderer.scrollBy(0, 2 * e.renderer.layerConfig.lineHeight); }, + readOnly: true +}, { + name: "selectlinestart", + description: "Select line start", + bindKey: "Shift-Home", + exec: function(editor) { editor.getSelection().selectLineStart(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectlineend", + description: "Select line end", + bindKey: "Shift-End", + exec: function(editor) { editor.getSelection().selectLineEnd(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "togglerecording", + description: "Toggle recording", + bindKey: bindKey("Ctrl-Alt-E", "Command-Option-E"), + exec: function(editor) { editor.commands.toggleRecording(editor); }, + readOnly: true +}, { + name: "replaymacro", + description: "Replay macro", + bindKey: bindKey("Ctrl-Shift-E", "Command-Shift-E"), + exec: function(editor) { editor.commands.replay(editor); }, + readOnly: true +}, { + name: "jumptomatching", + description: "Jump to matching", + bindKey: bindKey("Ctrl-\\|Ctrl-P", "Command-\\"), + exec: function(editor) { editor.jumpToMatching(); }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: true +}, { + name: "selecttomatching", + description: "Select to matching", + bindKey: bindKey("Ctrl-Shift-\\|Ctrl-Shift-P", "Command-Shift-\\"), + exec: function(editor) { editor.jumpToMatching(true); }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: true +}, { + name: "expandToMatching", + description: "Expand to matching", + bindKey: bindKey("Ctrl-Shift-M", "Ctrl-Shift-M"), + exec: function(editor) { editor.jumpToMatching(true, true); }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: true +}, { + name: "passKeysToBrowser", + description: "Pass keys to browser", + bindKey: bindKey(null, null), + exec: function() {}, + passEvent: true, + readOnly: true +}, { + name: "copy", + description: "Copy", + exec: function(editor) { + }, + readOnly: true +}, +{ + name: "cut", + description: "Cut", + exec: function(editor) { + var cutLine = editor.$copyWithEmptySelection && editor.selection.isEmpty(); + var range = cutLine ? editor.selection.getLineRange() : editor.selection.getRange(); + editor._emit("cut", range); + + if (!range.isEmpty()) + editor.session.remove(range); + editor.clearSelection(); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" +}, { + name: "paste", + description: "Paste", + exec: function(editor, args) { + editor.$handlePaste(args); + }, + scrollIntoView: "cursor" +}, { + name: "removeline", + description: "Remove line", + bindKey: bindKey("Ctrl-D", "Command-D"), + exec: function(editor) { editor.removeLines(); }, + scrollIntoView: "cursor", + multiSelectAction: "forEachLine" +}, { + name: "duplicateSelection", + description: "Duplicate selection", + bindKey: bindKey("Ctrl-Shift-D", "Command-Shift-D"), + exec: function(editor) { editor.duplicateSelection(); }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" +}, { + name: "sortlines", + description: "Sort lines", + bindKey: bindKey("Ctrl-Alt-S", "Command-Alt-S"), + exec: function(editor) { editor.sortLines(); }, + scrollIntoView: "selection", + multiSelectAction: "forEachLine" +}, { + name: "togglecomment", + description: "Toggle comment", + bindKey: bindKey("Ctrl-/", "Command-/"), + exec: function(editor) { editor.toggleCommentLines(); }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" +}, { + name: "toggleBlockComment", + description: "Toggle block comment", + bindKey: bindKey("Ctrl-Shift-/", "Command-Shift-/"), + exec: function(editor) { editor.toggleBlockComment(); }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" +}, { + name: "modifyNumberUp", + description: "Modify number up", + bindKey: bindKey("Ctrl-Shift-Up", "Alt-Shift-Up"), + exec: function(editor) { editor.modifyNumber(1); }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" +}, { + name: "modifyNumberDown", + description: "Modify number down", + bindKey: bindKey("Ctrl-Shift-Down", "Alt-Shift-Down"), + exec: function(editor) { editor.modifyNumber(-1); }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" +}, { + name: "replace", + description: "Replace", + bindKey: bindKey("Ctrl-H", "Command-Option-F"), + exec: function(editor) { + config.loadModule("ace/ext/searchbox", function(e) {e.Search(editor, true);}); + } +}, { + name: "undo", + description: "Undo", + bindKey: bindKey("Ctrl-Z", "Command-Z"), + exec: function(editor) { editor.undo(); } +}, { + name: "redo", + description: "Redo", + bindKey: bindKey("Ctrl-Shift-Z|Ctrl-Y", "Command-Shift-Z|Command-Y"), + exec: function(editor) { editor.redo(); } +}, { + name: "copylinesup", + description: "Copy lines up", + bindKey: bindKey("Alt-Shift-Up", "Command-Option-Up"), + exec: function(editor) { editor.copyLinesUp(); }, + scrollIntoView: "cursor" +}, { + name: "movelinesup", + description: "Move lines up", + bindKey: bindKey("Alt-Up", "Option-Up"), + exec: function(editor) { editor.moveLinesUp(); }, + scrollIntoView: "cursor" +}, { + name: "copylinesdown", + description: "Copy lines down", + bindKey: bindKey("Alt-Shift-Down", "Command-Option-Down"), + exec: function(editor) { editor.copyLinesDown(); }, + scrollIntoView: "cursor" +}, { + name: "movelinesdown", + description: "Move lines down", + bindKey: bindKey("Alt-Down", "Option-Down"), + exec: function(editor) { editor.moveLinesDown(); }, + scrollIntoView: "cursor" +}, { + name: "del", + description: "Delete", + bindKey: bindKey("Delete", "Delete|Ctrl-D|Shift-Delete"), + exec: function(editor) { editor.remove("right"); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "backspace", + description: "Backspace", + bindKey: bindKey( + "Shift-Backspace|Backspace", + "Ctrl-Backspace|Shift-Backspace|Backspace|Ctrl-H" + ), + exec: function(editor) { editor.remove("left"); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "cut_or_delete", + description: "Cut or delete", + bindKey: bindKey("Shift-Delete", null), + exec: function(editor) { + if (editor.selection.isEmpty()) { + editor.remove("left"); + } else { + return false; + } + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removetolinestart", + description: "Remove to line start", + bindKey: bindKey("Alt-Backspace", "Command-Backspace"), + exec: function(editor) { editor.removeToLineStart(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removetolineend", + description: "Remove to line end", + bindKey: bindKey("Alt-Delete", "Ctrl-K|Command-Delete"), + exec: function(editor) { editor.removeToLineEnd(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removetolinestarthard", + description: "Remove to line start hard", + bindKey: bindKey("Ctrl-Shift-Backspace", null), + exec: function(editor) { + var range = editor.selection.getRange(); + range.start.column = 0; + editor.session.remove(range); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removetolineendhard", + description: "Remove to line end hard", + bindKey: bindKey("Ctrl-Shift-Delete", null), + exec: function(editor) { + var range = editor.selection.getRange(); + range.end.column = Number.MAX_VALUE; + editor.session.remove(range); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removewordleft", + description: "Remove word left", + bindKey: bindKey("Ctrl-Backspace", "Alt-Backspace|Ctrl-Alt-Backspace"), + exec: function(editor) { editor.removeWordLeft(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "removewordright", + description: "Remove word right", + bindKey: bindKey("Ctrl-Delete", "Alt-Delete"), + exec: function(editor) { editor.removeWordRight(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "outdent", + description: "Outdent", + bindKey: bindKey("Shift-Tab", "Shift-Tab"), + exec: function(editor) { editor.blockOutdent(); }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" +}, { + name: "indent", + description: "Indent", + bindKey: bindKey("Tab", "Tab"), + exec: function(editor) { editor.indent(); }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" +}, { + name: "blockoutdent", + description: "Block outdent", + bindKey: bindKey("Ctrl-[", "Ctrl-["), + exec: function(editor) { editor.blockOutdent(); }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" +}, { + name: "blockindent", + description: "Block indent", + bindKey: bindKey("Ctrl-]", "Ctrl-]"), + exec: function(editor) { editor.blockIndent(); }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" +}, { + name: "insertstring", + description: "Insert string", + exec: function(editor, str) { editor.insert(str); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "inserttext", + description: "Insert text", + exec: function(editor, args) { + editor.insert(lang.stringRepeat(args.text || "", args.times || 1)); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "splitline", + description: "Split line", + bindKey: bindKey(null, "Ctrl-O"), + exec: function(editor) { editor.splitLine(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "transposeletters", + description: "Transpose letters", + bindKey: bindKey("Alt-Shift-X", "Ctrl-T"), + exec: function(editor) { editor.transposeLetters(); }, + multiSelectAction: function(editor) {editor.transposeSelections(1); }, + scrollIntoView: "cursor" +}, { + name: "touppercase", + description: "To uppercase", + bindKey: bindKey("Ctrl-U", "Ctrl-U"), + exec: function(editor) { editor.toUpperCase(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "tolowercase", + description: "To lowercase", + bindKey: bindKey("Ctrl-Shift-U", "Ctrl-Shift-U"), + exec: function(editor) { editor.toLowerCase(); }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "autoindent", + description: "Auto Indent", + bindKey: bindKey(null, null), + exec: function(editor) { editor.autoIndent(); }, + multiSelectAction: "forEachLine", + scrollIntoView: "animate" +}, { + name: "expandtoline", + description: "Expand to line", + bindKey: bindKey("Ctrl-Shift-L", "Command-Shift-L"), + exec: function(editor) { + var range = editor.selection.getRange(); + + range.start.column = range.end.column = 0; + range.end.row++; + editor.selection.setRange(range, false); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: true +}, { + name: "joinlines", + description: "Join lines", + bindKey: bindKey(null, null), + exec: function(editor) { + var isBackwards = editor.selection.isBackwards(); + var selectionStart = isBackwards ? editor.selection.getSelectionLead() : editor.selection.getSelectionAnchor(); + var selectionEnd = isBackwards ? editor.selection.getSelectionAnchor() : editor.selection.getSelectionLead(); + var firstLineEndCol = editor.session.doc.getLine(selectionStart.row).length; + var selectedText = editor.session.doc.getTextRange(editor.selection.getRange()); + var selectedCount = selectedText.replace(/\n\s*/, " ").length; + var insertLine = editor.session.doc.getLine(selectionStart.row); + + for (var i = selectionStart.row + 1; i <= selectionEnd.row + 1; i++) { + var curLine = lang.stringTrimLeft(lang.stringTrimRight(editor.session.doc.getLine(i))); + if (curLine.length !== 0) { + curLine = " " + curLine; + } + insertLine += curLine; + } + + if (selectionEnd.row + 1 < (editor.session.doc.getLength() - 1)) { + insertLine += editor.session.doc.getNewLineCharacter(); + } + + editor.clearSelection(); + editor.session.doc.replace(new Range(selectionStart.row, 0, selectionEnd.row + 2, 0), insertLine); + + if (selectedCount > 0) { + editor.selection.moveCursorTo(selectionStart.row, selectionStart.column); + editor.selection.selectTo(selectionStart.row, selectionStart.column + selectedCount); + } else { + firstLineEndCol = editor.session.doc.getLine(selectionStart.row).length > firstLineEndCol ? (firstLineEndCol + 1) : firstLineEndCol; + editor.selection.moveCursorTo(selectionStart.row, firstLineEndCol); + } + }, + multiSelectAction: "forEach", + readOnly: true +}, { + name: "invertSelection", + description: "Invert selection", + bindKey: bindKey(null, null), + exec: function(editor) { + var endRow = editor.session.doc.getLength() - 1; + var endCol = editor.session.doc.getLine(endRow).length; + var ranges = editor.selection.rangeList.ranges; + var newRanges = []; + if (ranges.length < 1) { + ranges = [editor.selection.getRange()]; + } + + for (var i = 0; i < ranges.length; i++) { + if (i == (ranges.length - 1)) { + if (!(ranges[i].end.row === endRow && ranges[i].end.column === endCol)) { + newRanges.push(new Range(ranges[i].end.row, ranges[i].end.column, endRow, endCol)); + } + } + + if (i === 0) { + if (!(ranges[i].start.row === 0 && ranges[i].start.column === 0)) { + newRanges.push(new Range(0, 0, ranges[i].start.row, ranges[i].start.column)); + } + } else { + newRanges.push(new Range(ranges[i-1].end.row, ranges[i-1].end.column, ranges[i].start.row, ranges[i].start.column)); + } + } + + editor.exitMultiSelectMode(); + editor.clearSelection(); + + for(var i = 0; i < newRanges.length; i++) { + editor.selection.addRange(newRanges[i], false); + } + }, + readOnly: true, + scrollIntoView: "none" +}, { + name: "addLineAfter", + description: "Add new line after the current line", + exec: function(editor) { + editor.selection.clearSelection(); + editor.navigateLineEnd(); + editor.insert("\n"); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "addLineBefore", + description: "Add new line before the current line", + exec: function(editor) { + editor.selection.clearSelection(); + var cursor = editor.getCursorPosition(); + editor.selection.moveTo(cursor.row - 1, Number.MAX_VALUE); + editor.insert("\n"); + if (cursor.row === 0) editor.navigateUp(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" +}, { + name: "openCommandPallete", + description: "Open command pallete", + bindKey: bindKey("F1", "F1"), + exec: function(editor) { + editor.prompt({ $type: "commands" }); + }, + readOnly: true +}, { + name: "modeSelect", + description: "Change language mode...", + bindKey: bindKey(null, null), + exec: function(editor) { + editor.prompt({ $type: "modes" }); + }, + readOnly: true +}]; + +for (var i = 1; i < 9; i++) { + exports.commands.push({ + name: "foldToLevel" + i, + description: "Fold To Level " + i, + level: i, + exec: function(editor) { editor.session.foldToLevel(this.level); }, + scrollIntoView: "center", + readOnly: true + }); +} + +}); + +ace.define("ace/editor",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/lib/useragent","ace/keyboard/textinput","ace/mouse/mouse_handler","ace/mouse/fold_handler","ace/keyboard/keybinding","ace/edit_session","ace/search","ace/range","ace/lib/event_emitter","ace/commands/command_manager","ace/commands/default_commands","ace/config","ace/token_iterator","ace/clipboard"], function(require, exports, module) { +"use strict"; + +require("./lib/fixoldbrowsers"); + +var oop = require("./lib/oop"); +var dom = require("./lib/dom"); +var lang = require("./lib/lang"); +var useragent = require("./lib/useragent"); +var TextInput = require("./keyboard/textinput").TextInput; +var MouseHandler = require("./mouse/mouse_handler").MouseHandler; +var FoldHandler = require("./mouse/fold_handler").FoldHandler; +var KeyBinding = require("./keyboard/keybinding").KeyBinding; +var EditSession = require("./edit_session").EditSession; +var Search = require("./search").Search; +var Range = require("./range").Range; +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var CommandManager = require("./commands/command_manager").CommandManager; +var defaultCommands = require("./commands/default_commands").commands; +var config = require("./config"); +var TokenIterator = require("./token_iterator").TokenIterator; + +var clipboard = require("./clipboard"); +var Editor = function(renderer, session, options) { + this.$toDestroy = []; + var container = renderer.getContainerElement(); + this.container = container; + this.renderer = renderer; + this.id = "editor" + (++Editor.$uid); + + this.commands = new CommandManager(useragent.isMac ? "mac" : "win", defaultCommands); + if (typeof document == "object") { + this.textInput = new TextInput(renderer.getTextAreaContainer(), this); + this.renderer.textarea = this.textInput.getElement(); + this.$mouseHandler = new MouseHandler(this); + new FoldHandler(this); + } + + this.keyBinding = new KeyBinding(this); + + this.$search = new Search().set({ + wrap: true + }); + + this.$historyTracker = this.$historyTracker.bind(this); + this.commands.on("exec", this.$historyTracker); + + this.$initOperationListeners(); + + this._$emitInputEvent = lang.delayedCall(function() { + this._signal("input", {}); + if (this.session && this.session.bgTokenizer) + this.session.bgTokenizer.scheduleStart(); + }.bind(this)); + + this.on("change", function(_, _self) { + _self._$emitInputEvent.schedule(31); + }); + + this.setSession(session || options && options.session || new EditSession("")); + config.resetOptions(this); + if (options) + this.setOptions(options); + config._signal("editor", this); +}; + +Editor.$uid = 0; + +(function(){ + + oop.implement(this, EventEmitter); + + this.$initOperationListeners = function() { + this.commands.on("exec", this.startOperation.bind(this), true); + this.commands.on("afterExec", this.endOperation.bind(this), true); + + this.$opResetTimer = lang.delayedCall(this.endOperation.bind(this, true)); + this.on("change", function() { + if (!this.curOp) { + this.startOperation(); + this.curOp.selectionBefore = this.$lastSel; + } + this.curOp.docChanged = true; + }.bind(this), true); + + this.on("changeSelection", function() { + if (!this.curOp) { + this.startOperation(); + this.curOp.selectionBefore = this.$lastSel; + } + this.curOp.selectionChanged = true; + }.bind(this), true); + }; + + this.curOp = null; + this.prevOp = {}; + this.startOperation = function(commandEvent) { + if (this.curOp) { + if (!commandEvent || this.curOp.command) + return; + this.prevOp = this.curOp; + } + if (!commandEvent) { + this.previousCommand = null; + commandEvent = {}; + } + + this.$opResetTimer.schedule(); + this.curOp = this.session.curOp = { + command: commandEvent.command || {}, + args: commandEvent.args, + scrollTop: this.renderer.scrollTop + }; + this.curOp.selectionBefore = this.selection.toJSON(); + }; + + this.endOperation = function(e) { + if (this.curOp && this.session) { + if (e && e.returnValue === false || !this.session) + return (this.curOp = null); + if (e == true && this.curOp.command && this.curOp.command.name == "mouse") + return; + this._signal("beforeEndOperation"); + if (!this.curOp) return; + var command = this.curOp.command; + var scrollIntoView = command && command.scrollIntoView; + if (scrollIntoView) { + switch (scrollIntoView) { + case "center-animate": + scrollIntoView = "animate"; + case "center": + this.renderer.scrollCursorIntoView(null, 0.5); + break; + case "animate": + case "cursor": + this.renderer.scrollCursorIntoView(); + break; + case "selectionPart": + var range = this.selection.getRange(); + var config = this.renderer.layerConfig; + if (range.start.row >= config.lastRow || range.end.row <= config.firstRow) { + this.renderer.scrollSelectionIntoView(this.selection.anchor, this.selection.lead); + } + break; + default: + break; + } + if (scrollIntoView == "animate") + this.renderer.animateScrolling(this.curOp.scrollTop); + } + var sel = this.selection.toJSON(); + this.curOp.selectionAfter = sel; + this.$lastSel = this.selection.toJSON(); + this.session.getUndoManager().addSelection(sel); + this.prevOp = this.curOp; + this.curOp = null; + } + }; + this.$mergeableCommands = ["backspace", "del", "insertstring"]; + this.$historyTracker = function(e) { + if (!this.$mergeUndoDeltas) + return; + + var prev = this.prevOp; + var mergeableCommands = this.$mergeableCommands; + var shouldMerge = prev.command && (e.command.name == prev.command.name); + if (e.command.name == "insertstring") { + var text = e.args; + if (this.mergeNextCommand === undefined) + this.mergeNextCommand = true; + + shouldMerge = shouldMerge + && this.mergeNextCommand // previous command allows to coalesce with + && (!/\s/.test(text) || /\s/.test(prev.args)); // previous insertion was of same type + + this.mergeNextCommand = true; + } else { + shouldMerge = shouldMerge + && mergeableCommands.indexOf(e.command.name) !== -1; // the command is mergeable + } + + if ( + this.$mergeUndoDeltas != "always" + && Date.now() - this.sequenceStartTime > 2000 + ) { + shouldMerge = false; // the sequence is too long + } + + if (shouldMerge) + this.session.mergeUndoDeltas = true; + else if (mergeableCommands.indexOf(e.command.name) !== -1) + this.sequenceStartTime = Date.now(); + }; + this.setKeyboardHandler = function(keyboardHandler, cb) { + if (keyboardHandler && typeof keyboardHandler === "string" && keyboardHandler != "ace") { + this.$keybindingId = keyboardHandler; + var _self = this; + config.loadModule(["keybinding", keyboardHandler], function(module) { + if (_self.$keybindingId == keyboardHandler) + _self.keyBinding.setKeyboardHandler(module && module.handler); + cb && cb(); + }); + } else { + this.$keybindingId = null; + this.keyBinding.setKeyboardHandler(keyboardHandler); + cb && cb(); + } + }; + this.getKeyboardHandler = function() { + return this.keyBinding.getKeyboardHandler(); + }; + this.setSession = function(session) { + if (this.session == session) + return; + if (this.curOp) this.endOperation(); + this.curOp = {}; + + var oldSession = this.session; + if (oldSession) { + this.session.off("change", this.$onDocumentChange); + this.session.off("changeMode", this.$onChangeMode); + this.session.off("tokenizerUpdate", this.$onTokenizerUpdate); + this.session.off("changeTabSize", this.$onChangeTabSize); + this.session.off("changeWrapLimit", this.$onChangeWrapLimit); + this.session.off("changeWrapMode", this.$onChangeWrapMode); + this.session.off("changeFold", this.$onChangeFold); + this.session.off("changeFrontMarker", this.$onChangeFrontMarker); + this.session.off("changeBackMarker", this.$onChangeBackMarker); + this.session.off("changeBreakpoint", this.$onChangeBreakpoint); + this.session.off("changeAnnotation", this.$onChangeAnnotation); + this.session.off("changeOverwrite", this.$onCursorChange); + this.session.off("changeScrollTop", this.$onScrollTopChange); + this.session.off("changeScrollLeft", this.$onScrollLeftChange); + + var selection = this.session.getSelection(); + selection.off("changeCursor", this.$onCursorChange); + selection.off("changeSelection", this.$onSelectionChange); + } + + this.session = session; + if (session) { + this.$onDocumentChange = this.onDocumentChange.bind(this); + session.on("change", this.$onDocumentChange); + this.renderer.setSession(session); + + this.$onChangeMode = this.onChangeMode.bind(this); + session.on("changeMode", this.$onChangeMode); + + this.$onTokenizerUpdate = this.onTokenizerUpdate.bind(this); + session.on("tokenizerUpdate", this.$onTokenizerUpdate); + + this.$onChangeTabSize = this.renderer.onChangeTabSize.bind(this.renderer); + session.on("changeTabSize", this.$onChangeTabSize); + + this.$onChangeWrapLimit = this.onChangeWrapLimit.bind(this); + session.on("changeWrapLimit", this.$onChangeWrapLimit); + + this.$onChangeWrapMode = this.onChangeWrapMode.bind(this); + session.on("changeWrapMode", this.$onChangeWrapMode); + + this.$onChangeFold = this.onChangeFold.bind(this); + session.on("changeFold", this.$onChangeFold); + + this.$onChangeFrontMarker = this.onChangeFrontMarker.bind(this); + this.session.on("changeFrontMarker", this.$onChangeFrontMarker); + + this.$onChangeBackMarker = this.onChangeBackMarker.bind(this); + this.session.on("changeBackMarker", this.$onChangeBackMarker); + + this.$onChangeBreakpoint = this.onChangeBreakpoint.bind(this); + this.session.on("changeBreakpoint", this.$onChangeBreakpoint); + + this.$onChangeAnnotation = this.onChangeAnnotation.bind(this); + this.session.on("changeAnnotation", this.$onChangeAnnotation); + + this.$onCursorChange = this.onCursorChange.bind(this); + this.session.on("changeOverwrite", this.$onCursorChange); + + this.$onScrollTopChange = this.onScrollTopChange.bind(this); + this.session.on("changeScrollTop", this.$onScrollTopChange); + + this.$onScrollLeftChange = this.onScrollLeftChange.bind(this); + this.session.on("changeScrollLeft", this.$onScrollLeftChange); + + this.selection = session.getSelection(); + this.selection.on("changeCursor", this.$onCursorChange); + + this.$onSelectionChange = this.onSelectionChange.bind(this); + this.selection.on("changeSelection", this.$onSelectionChange); + + this.onChangeMode(); + + this.onCursorChange(); + + this.onScrollTopChange(); + this.onScrollLeftChange(); + this.onSelectionChange(); + this.onChangeFrontMarker(); + this.onChangeBackMarker(); + this.onChangeBreakpoint(); + this.onChangeAnnotation(); + this.session.getUseWrapMode() && this.renderer.adjustWrapLimit(); + this.renderer.updateFull(); + } else { + this.selection = null; + this.renderer.setSession(session); + } + + this._signal("changeSession", { + session: session, + oldSession: oldSession + }); + + this.curOp = null; + + oldSession && oldSession._signal("changeEditor", {oldEditor: this}); + session && session._signal("changeEditor", {editor: this}); + + if (session && session.bgTokenizer) + session.bgTokenizer.scheduleStart(); + }; + this.getSession = function() { + return this.session; + }; + this.setValue = function(val, cursorPos) { + this.session.doc.setValue(val); + + if (!cursorPos) + this.selectAll(); + else if (cursorPos == 1) + this.navigateFileEnd(); + else if (cursorPos == -1) + this.navigateFileStart(); + + return val; + }; + this.getValue = function() { + return this.session.getValue(); + }; + this.getSelection = function() { + return this.selection; + }; + this.resize = function(force) { + this.renderer.onResize(force); + }; + this.setTheme = function(theme, cb) { + this.renderer.setTheme(theme, cb); + }; + this.getTheme = function() { + return this.renderer.getTheme(); + }; + this.setStyle = function(style) { + this.renderer.setStyle(style); + }; + this.unsetStyle = function(style) { + this.renderer.unsetStyle(style); + }; + this.getFontSize = function () { + return this.getOption("fontSize") || + dom.computedStyle(this.container).fontSize; + }; + this.setFontSize = function(size) { + this.setOption("fontSize", size); + }; + + this.$highlightBrackets = function() { + if (this.$highlightPending) { + return; + } + var self = this; + this.$highlightPending = true; + setTimeout(function () { + self.$highlightPending = false; + var session = self.session; + if (!session || !session.bgTokenizer) return; + if (session.$bracketHighlight) { + session.$bracketHighlight.markerIds.forEach(function(id) { + session.removeMarker(id); + }); + session.$bracketHighlight = null; + } + var ranges = session.getMatchingBracketRanges(self.getCursorPosition()); + if (!ranges && session.$mode.getMatching) + ranges = session.$mode.getMatching(self.session); + if (!ranges) + return; + + var markerType = "ace_bracket"; + if (!Array.isArray(ranges)) { + ranges = [ranges]; + } else if (ranges.length == 1) { + markerType = "ace_error_bracket"; + } + if (ranges.length == 2) { + if (Range.comparePoints(ranges[0].end, ranges[1].start) == 0) + ranges = [Range.fromPoints(ranges[0].start, ranges[1].end)]; + else if (Range.comparePoints(ranges[0].start, ranges[1].end) == 0) + ranges = [Range.fromPoints(ranges[1].start, ranges[0].end)]; + } + + session.$bracketHighlight = { + ranges: ranges, + markerIds: ranges.map(function(range) { + return session.addMarker(range, markerType, "text"); + }) + }; + }, 50); + }; + this.$highlightTags = function() { + if (this.$highlightTagPending) + return; + var self = this; + this.$highlightTagPending = true; + setTimeout(function() { + self.$highlightTagPending = false; + + var session = self.session; + if (!session || !session.bgTokenizer) return; + + var pos = self.getCursorPosition(); + var iterator = new TokenIterator(self.session, pos.row, pos.column); + var token = iterator.getCurrentToken(); + + if (!token || !/\b(?:tag-open|tag-name)/.test(token.type)) { + session.removeMarker(session.$tagHighlight); + session.$tagHighlight = null; + return; + } + + if (token.type.indexOf("tag-open") !== -1) { + token = iterator.stepForward(); + if (!token) + return; + } + + var tag = token.value; + var currentTag = token.value; + var depth = 0; + var prevToken = iterator.stepBackward(); + + if (prevToken.value === '<'){ + do { + prevToken = token; + token = iterator.stepForward(); + + if (token) { + if (token.type.indexOf('tag-name') !== -1) { + currentTag = token.value; + if (tag === currentTag) { + if (prevToken.value === '<') { + depth++; + } else if (prevToken.value === '') { // self closing tag + depth--; + } + } + + } while (token && depth >= 0); + } else { + do { + token = prevToken; + prevToken = iterator.stepBackward(); + + if (token) { + if (token.type.indexOf('tag-name') !== -1) { + if (tag === token.value) { + if (prevToken.value === '<') { + depth++; + } else if (prevToken.value === '') { // self closing tag + var stepCount = 0; + var tmpToken = prevToken; + while (tmpToken) { + if (tmpToken.type.indexOf('tag-name') !== -1 && tmpToken.value === tag) { + depth--; + break; + } else if (tmpToken.value === '<') { + break; + } + tmpToken = iterator.stepBackward(); + stepCount++; + } + for (var i = 0; i < stepCount; i++) { + iterator.stepForward(); + } + } + } + } while (prevToken && depth <= 0); + iterator.stepForward(); + } + + if (!token) { + session.removeMarker(session.$tagHighlight); + session.$tagHighlight = null; + return; + } + + var row = iterator.getCurrentTokenRow(); + var column = iterator.getCurrentTokenColumn(); + var range = new Range(row, column, row, column+token.value.length); + var sbm = session.$backMarkers[session.$tagHighlight]; + if (session.$tagHighlight && sbm != undefined && range.compareRange(sbm.range) !== 0) { + session.removeMarker(session.$tagHighlight); + session.$tagHighlight = null; + } + + if (!session.$tagHighlight) + session.$tagHighlight = session.addMarker(range, "ace_bracket", "text"); + }, 50); + }; + this.focus = function() { + var _self = this; + setTimeout(function() { + if (!_self.isFocused()) + _self.textInput.focus(); + }); + this.textInput.focus(); + }; + this.isFocused = function() { + return this.textInput.isFocused(); + }; + this.blur = function() { + this.textInput.blur(); + }; + this.onFocus = function(e) { + if (this.$isFocused) + return; + this.$isFocused = true; + this.renderer.showCursor(); + this.renderer.visualizeFocus(); + this._emit("focus", e); + }; + this.onBlur = function(e) { + if (!this.$isFocused) + return; + this.$isFocused = false; + this.renderer.hideCursor(); + this.renderer.visualizeBlur(); + this._emit("blur", e); + }; + + this.$cursorChange = function() { + this.renderer.updateCursor(); + this.$highlightBrackets(); + this.$highlightTags(); + this.$updateHighlightActiveLine(); + }; + this.onDocumentChange = function(delta) { + var wrap = this.session.$useWrapMode; + var lastRow = (delta.start.row == delta.end.row ? delta.end.row : Infinity); + this.renderer.updateLines(delta.start.row, lastRow, wrap); + + this._signal("change", delta); + this.$cursorChange(); + }; + + this.onTokenizerUpdate = function(e) { + var rows = e.data; + this.renderer.updateLines(rows.first, rows.last); + }; + + + this.onScrollTopChange = function() { + this.renderer.scrollToY(this.session.getScrollTop()); + }; + + this.onScrollLeftChange = function() { + this.renderer.scrollToX(this.session.getScrollLeft()); + }; + this.onCursorChange = function() { + this.$cursorChange(); + this._signal("changeSelection"); + }; + + this.$updateHighlightActiveLine = function() { + var session = this.getSession(); + + var highlight; + if (this.$highlightActiveLine) { + if (this.$selectionStyle != "line" || !this.selection.isMultiLine()) + highlight = this.getCursorPosition(); + if (this.renderer.theme && this.renderer.theme.$selectionColorConflict && !this.selection.isEmpty()) + highlight = false; + if (this.renderer.$maxLines && this.session.getLength() === 1 && !(this.renderer.$minLines > 1)) + highlight = false; + } + + if (session.$highlightLineMarker && !highlight) { + session.removeMarker(session.$highlightLineMarker.id); + session.$highlightLineMarker = null; + } else if (!session.$highlightLineMarker && highlight) { + var range = new Range(highlight.row, highlight.column, highlight.row, Infinity); + range.id = session.addMarker(range, "ace_active-line", "screenLine"); + session.$highlightLineMarker = range; + } else if (highlight) { + session.$highlightLineMarker.start.row = highlight.row; + session.$highlightLineMarker.end.row = highlight.row; + session.$highlightLineMarker.start.column = highlight.column; + session._signal("changeBackMarker"); + } + }; + + this.onSelectionChange = function(e) { + var session = this.session; + + if (session.$selectionMarker) { + session.removeMarker(session.$selectionMarker); + } + session.$selectionMarker = null; + + if (!this.selection.isEmpty()) { + var range = this.selection.getRange(); + var style = this.getSelectionStyle(); + session.$selectionMarker = session.addMarker(range, "ace_selection", style); + } else { + this.$updateHighlightActiveLine(); + } + + var re = this.$highlightSelectedWord && this.$getSelectionHighLightRegexp(); + this.session.highlight(re); + + this._signal("changeSelection"); + }; + + this.$getSelectionHighLightRegexp = function() { + var session = this.session; + + var selection = this.getSelectionRange(); + if (selection.isEmpty() || selection.isMultiLine()) + return; + + var startColumn = selection.start.column; + var endColumn = selection.end.column; + var line = session.getLine(selection.start.row); + + var needle = line.substring(startColumn, endColumn); + if (needle.length > 5000 || !/[\w\d]/.test(needle)) + return; + + var re = this.$search.$assembleRegExp({ + wholeWord: true, + caseSensitive: true, + needle: needle + }); + + var wordWithBoundary = line.substring(startColumn - 1, endColumn + 1); + if (!re.test(wordWithBoundary)) + return; + + return re; + }; + + + this.onChangeFrontMarker = function() { + this.renderer.updateFrontMarkers(); + }; + + this.onChangeBackMarker = function() { + this.renderer.updateBackMarkers(); + }; + + + this.onChangeBreakpoint = function() { + this.renderer.updateBreakpoints(); + }; + + this.onChangeAnnotation = function() { + this.renderer.setAnnotations(this.session.getAnnotations()); + }; + + + this.onChangeMode = function(e) { + this.renderer.updateText(); + this._emit("changeMode", e); + }; + + + this.onChangeWrapLimit = function() { + this.renderer.updateFull(); + }; + + this.onChangeWrapMode = function() { + this.renderer.onResize(true); + }; + + + this.onChangeFold = function() { + this.$updateHighlightActiveLine(); + this.renderer.updateFull(); + }; + this.getSelectedText = function() { + return this.session.getTextRange(this.getSelectionRange()); + }; + this.getCopyText = function() { + var text = this.getSelectedText(); + var nl = this.session.doc.getNewLineCharacter(); + var copyLine= false; + if (!text && this.$copyWithEmptySelection) { + copyLine = true; + var ranges = this.selection.getAllRanges(); + for (var i = 0; i < ranges.length; i++) { + var range = ranges[i]; + if (i && ranges[i - 1].start.row == range.start.row) + continue; + text += this.session.getLine(range.start.row) + nl; + } + } + var e = {text: text}; + this._signal("copy", e); + clipboard.lineMode = copyLine ? e.text : false; + return e.text; + }; + this.onCopy = function() { + this.commands.exec("copy", this); + }; + this.onCut = function() { + this.commands.exec("cut", this); + }; + this.onPaste = function(text, event) { + var e = {text: text, event: event}; + this.commands.exec("paste", this, e); + }; + + this.$handlePaste = function(e) { + if (typeof e == "string") + e = {text: e}; + this._signal("paste", e); + var text = e.text; + + var lineMode = text === clipboard.lineMode; + var session = this.session; + if (!this.inMultiSelectMode || this.inVirtualSelectionMode) { + if (lineMode) + session.insert({ row: this.selection.lead.row, column: 0 }, text); + else + this.insert(text); + } else if (lineMode) { + this.selection.rangeList.ranges.forEach(function(range) { + session.insert({ row: range.start.row, column: 0 }, text); + }); + } else { + var lines = text.split(/\r\n|\r|\n/); + var ranges = this.selection.rangeList.ranges; + + var isFullLine = lines.length == 2 && (!lines[0] || !lines[1]); + if (lines.length != ranges.length || isFullLine) + return this.commands.exec("insertstring", this, text); + + for (var i = ranges.length; i--;) { + var range = ranges[i]; + if (!range.isEmpty()) + session.remove(range); + + session.insert(range.start, lines[i]); + } + } + }; + + this.execCommand = function(command, args) { + return this.commands.exec(command, this, args); + }; + this.insert = function(text, pasted) { + var session = this.session; + var mode = session.getMode(); + var cursor = this.getCursorPosition(); + + if (this.getBehavioursEnabled() && !pasted) { + var transform = mode.transformAction(session.getState(cursor.row), 'insertion', this, session, text); + if (transform) { + if (text !== transform.text) { + if (!this.inVirtualSelectionMode) { + this.session.mergeUndoDeltas = false; + this.mergeNextCommand = false; + } + } + text = transform.text; + + } + } + + if (text == "\t") + text = this.session.getTabString(); + if (!this.selection.isEmpty()) { + var range = this.getSelectionRange(); + cursor = this.session.remove(range); + this.clearSelection(); + } + else if (this.session.getOverwrite() && text.indexOf("\n") == -1) { + var range = new Range.fromPoints(cursor, cursor); + range.end.column += text.length; + this.session.remove(range); + } + + if (text == "\n" || text == "\r\n") { + var line = session.getLine(cursor.row); + if (cursor.column > line.search(/\S|$/)) { + var d = line.substr(cursor.column).search(/\S|$/); + session.doc.removeInLine(cursor.row, cursor.column, cursor.column + d); + } + } + this.clearSelection(); + + var start = cursor.column; + var lineState = session.getState(cursor.row); + var line = session.getLine(cursor.row); + var shouldOutdent = mode.checkOutdent(lineState, line, text); + session.insert(cursor, text); + + if (transform && transform.selection) { + if (transform.selection.length == 2) { // Transform relative to the current column + this.selection.setSelectionRange( + new Range(cursor.row, start + transform.selection[0], + cursor.row, start + transform.selection[1])); + } else { // Transform relative to the current row. + this.selection.setSelectionRange( + new Range(cursor.row + transform.selection[0], + transform.selection[1], + cursor.row + transform.selection[2], + transform.selection[3])); + } + } + if (this.$enableAutoIndent) { + if (session.getDocument().isNewLine(text)) { + var lineIndent = mode.getNextLineIndent(lineState, line.slice(0, cursor.column), session.getTabString()); + + session.insert({row: cursor.row+1, column: 0}, lineIndent); + } + if (shouldOutdent) + mode.autoOutdent(lineState, session, cursor.row); + } + }; + + this.autoIndent = function () { + var session = this.session; + var mode = session.getMode(); + + var startRow, endRow; + if (this.selection.isEmpty()) { + startRow = 0; + endRow = session.doc.getLength() - 1; + } else { + var selectedRange = this.getSelectionRange(); + + startRow = selectedRange.start.row; + endRow = selectedRange.end.row; + } + + var prevLineState = ""; + var prevLine = ""; + var lineIndent = ""; + var line, currIndent, range; + var tab = session.getTabString(); + + for (var row = startRow; row <= endRow; row++) { + if (row > 0) { + prevLineState = session.getState(row - 1); + prevLine = session.getLine(row - 1); + lineIndent = mode.getNextLineIndent(prevLineState, prevLine, tab); + } + + line = session.getLine(row); + currIndent = mode.$getIndent(line); + if (lineIndent !== currIndent) { + if (currIndent.length > 0) { + range = new Range(row, 0, row, currIndent.length); + session.remove(range); + } + if (lineIndent.length > 0) { + session.insert({row: row, column: 0}, lineIndent); + } + } + + mode.autoOutdent(prevLineState, session, row); + } + }; + + + this.onTextInput = function(text, composition) { + if (!composition) + return this.keyBinding.onTextInput(text); + + this.startOperation({command: { name: "insertstring" }}); + var applyComposition = this.applyComposition.bind(this, text, composition); + if (this.selection.rangeCount) + this.forEachSelection(applyComposition); + else + applyComposition(); + this.endOperation(); + }; + + this.applyComposition = function(text, composition) { + if (composition.extendLeft || composition.extendRight) { + var r = this.selection.getRange(); + r.start.column -= composition.extendLeft; + r.end.column += composition.extendRight; + if (r.start.column < 0) { + r.start.row--; + r.start.column += this.session.getLine(r.start.row).length + 1; + } + this.selection.setRange(r); + if (!text && !r.isEmpty()) + this.remove(); + } + if (text || !this.selection.isEmpty()) + this.insert(text, true); + if (composition.restoreStart || composition.restoreEnd) { + var r = this.selection.getRange(); + r.start.column -= composition.restoreStart; + r.end.column -= composition.restoreEnd; + this.selection.setRange(r); + } + }; + + this.onCommandKey = function(e, hashId, keyCode) { + return this.keyBinding.onCommandKey(e, hashId, keyCode); + }; + this.setOverwrite = function(overwrite) { + this.session.setOverwrite(overwrite); + }; + this.getOverwrite = function() { + return this.session.getOverwrite(); + }; + this.toggleOverwrite = function() { + this.session.toggleOverwrite(); + }; + this.setScrollSpeed = function(speed) { + this.setOption("scrollSpeed", speed); + }; + this.getScrollSpeed = function() { + return this.getOption("scrollSpeed"); + }; + this.setDragDelay = function(dragDelay) { + this.setOption("dragDelay", dragDelay); + }; + this.getDragDelay = function() { + return this.getOption("dragDelay"); + }; + this.setSelectionStyle = function(val) { + this.setOption("selectionStyle", val); + }; + this.getSelectionStyle = function() { + return this.getOption("selectionStyle"); + }; + this.setHighlightActiveLine = function(shouldHighlight) { + this.setOption("highlightActiveLine", shouldHighlight); + }; + this.getHighlightActiveLine = function() { + return this.getOption("highlightActiveLine"); + }; + this.setHighlightGutterLine = function(shouldHighlight) { + this.setOption("highlightGutterLine", shouldHighlight); + }; + + this.getHighlightGutterLine = function() { + return this.getOption("highlightGutterLine"); + }; + this.setHighlightSelectedWord = function(shouldHighlight) { + this.setOption("highlightSelectedWord", shouldHighlight); + }; + this.getHighlightSelectedWord = function() { + return this.$highlightSelectedWord; + }; + + this.setAnimatedScroll = function(shouldAnimate){ + this.renderer.setAnimatedScroll(shouldAnimate); + }; + + this.getAnimatedScroll = function(){ + return this.renderer.getAnimatedScroll(); + }; + this.setShowInvisibles = function(showInvisibles) { + this.renderer.setShowInvisibles(showInvisibles); + }; + this.getShowInvisibles = function() { + return this.renderer.getShowInvisibles(); + }; + + this.setDisplayIndentGuides = function(display) { + this.renderer.setDisplayIndentGuides(display); + }; + + this.getDisplayIndentGuides = function() { + return this.renderer.getDisplayIndentGuides(); + }; + this.setShowPrintMargin = function(showPrintMargin) { + this.renderer.setShowPrintMargin(showPrintMargin); + }; + this.getShowPrintMargin = function() { + return this.renderer.getShowPrintMargin(); + }; + this.setPrintMarginColumn = function(showPrintMargin) { + this.renderer.setPrintMarginColumn(showPrintMargin); + }; + this.getPrintMarginColumn = function() { + return this.renderer.getPrintMarginColumn(); + }; + this.setReadOnly = function(readOnly) { + this.setOption("readOnly", readOnly); + }; + this.getReadOnly = function() { + return this.getOption("readOnly"); + }; + this.setBehavioursEnabled = function (enabled) { + this.setOption("behavioursEnabled", enabled); + }; + this.getBehavioursEnabled = function () { + return this.getOption("behavioursEnabled"); + }; + this.setWrapBehavioursEnabled = function (enabled) { + this.setOption("wrapBehavioursEnabled", enabled); + }; + this.getWrapBehavioursEnabled = function () { + return this.getOption("wrapBehavioursEnabled"); + }; + this.setShowFoldWidgets = function(show) { + this.setOption("showFoldWidgets", show); + + }; + this.getShowFoldWidgets = function() { + return this.getOption("showFoldWidgets"); + }; + + this.setFadeFoldWidgets = function(fade) { + this.setOption("fadeFoldWidgets", fade); + }; + + this.getFadeFoldWidgets = function() { + return this.getOption("fadeFoldWidgets"); + }; + this.remove = function(dir) { + if (this.selection.isEmpty()){ + if (dir == "left") + this.selection.selectLeft(); + else + this.selection.selectRight(); + } + + var range = this.getSelectionRange(); + if (this.getBehavioursEnabled()) { + var session = this.session; + var state = session.getState(range.start.row); + var new_range = session.getMode().transformAction(state, 'deletion', this, session, range); + + if (range.end.column === 0) { + var text = session.getTextRange(range); + if (text[text.length - 1] == "\n") { + var line = session.getLine(range.end.row); + if (/^\s+$/.test(line)) { + range.end.column = line.length; + } + } + } + if (new_range) + range = new_range; + } + + this.session.remove(range); + this.clearSelection(); + }; + this.removeWordRight = function() { + if (this.selection.isEmpty()) + this.selection.selectWordRight(); + + this.session.remove(this.getSelectionRange()); + this.clearSelection(); + }; + this.removeWordLeft = function() { + if (this.selection.isEmpty()) + this.selection.selectWordLeft(); + + this.session.remove(this.getSelectionRange()); + this.clearSelection(); + }; + this.removeToLineStart = function() { + if (this.selection.isEmpty()) + this.selection.selectLineStart(); + if (this.selection.isEmpty()) + this.selection.selectLeft(); + this.session.remove(this.getSelectionRange()); + this.clearSelection(); + }; + this.removeToLineEnd = function() { + if (this.selection.isEmpty()) + this.selection.selectLineEnd(); + + var range = this.getSelectionRange(); + if (range.start.column == range.end.column && range.start.row == range.end.row) { + range.end.column = 0; + range.end.row++; + } + + this.session.remove(range); + this.clearSelection(); + }; + this.splitLine = function() { + if (!this.selection.isEmpty()) { + this.session.remove(this.getSelectionRange()); + this.clearSelection(); + } + + var cursor = this.getCursorPosition(); + this.insert("\n"); + this.moveCursorToPosition(cursor); + }; + this.transposeLetters = function() { + if (!this.selection.isEmpty()) { + return; + } + + var cursor = this.getCursorPosition(); + var column = cursor.column; + if (column === 0) + return; + + var line = this.session.getLine(cursor.row); + var swap, range; + if (column < line.length) { + swap = line.charAt(column) + line.charAt(column-1); + range = new Range(cursor.row, column-1, cursor.row, column+1); + } + else { + swap = line.charAt(column-1) + line.charAt(column-2); + range = new Range(cursor.row, column-2, cursor.row, column); + } + this.session.replace(range, swap); + this.session.selection.moveToPosition(range.end); + }; + this.toLowerCase = function() { + var originalRange = this.getSelectionRange(); + if (this.selection.isEmpty()) { + this.selection.selectWord(); + } + + var range = this.getSelectionRange(); + var text = this.session.getTextRange(range); + this.session.replace(range, text.toLowerCase()); + this.selection.setSelectionRange(originalRange); + }; + this.toUpperCase = function() { + var originalRange = this.getSelectionRange(); + if (this.selection.isEmpty()) { + this.selection.selectWord(); + } + + var range = this.getSelectionRange(); + var text = this.session.getTextRange(range); + this.session.replace(range, text.toUpperCase()); + this.selection.setSelectionRange(originalRange); + }; + this.indent = function() { + var session = this.session; + var range = this.getSelectionRange(); + + if (range.start.row < range.end.row) { + var rows = this.$getSelectedRows(); + session.indentRows(rows.first, rows.last, "\t"); + return; + } else if (range.start.column < range.end.column) { + var text = session.getTextRange(range); + if (!/^\s+$/.test(text)) { + var rows = this.$getSelectedRows(); + session.indentRows(rows.first, rows.last, "\t"); + return; + } + } + + var line = session.getLine(range.start.row); + var position = range.start; + var size = session.getTabSize(); + var column = session.documentToScreenColumn(position.row, position.column); + + if (this.session.getUseSoftTabs()) { + var count = (size - column % size); + var indentString = lang.stringRepeat(" ", count); + } else { + var count = column % size; + while (line[range.start.column - 1] == " " && count) { + range.start.column--; + count--; + } + this.selection.setSelectionRange(range); + indentString = "\t"; + } + return this.insert(indentString); + }; + this.blockIndent = function() { + var rows = this.$getSelectedRows(); + this.session.indentRows(rows.first, rows.last, "\t"); + }; + this.blockOutdent = function() { + var selection = this.session.getSelection(); + this.session.outdentRows(selection.getRange()); + }; + this.sortLines = function() { + var rows = this.$getSelectedRows(); + var session = this.session; + + var lines = []; + for (var i = rows.first; i <= rows.last; i++) + lines.push(session.getLine(i)); + + lines.sort(function(a, b) { + if (a.toLowerCase() < b.toLowerCase()) return -1; + if (a.toLowerCase() > b.toLowerCase()) return 1; + return 0; + }); + + var deleteRange = new Range(0, 0, 0, 0); + for (var i = rows.first; i <= rows.last; i++) { + var line = session.getLine(i); + deleteRange.start.row = i; + deleteRange.end.row = i; + deleteRange.end.column = line.length; + session.replace(deleteRange, lines[i-rows.first]); + } + }; + this.toggleCommentLines = function() { + var state = this.session.getState(this.getCursorPosition().row); + var rows = this.$getSelectedRows(); + this.session.getMode().toggleCommentLines(state, this.session, rows.first, rows.last); + }; + + this.toggleBlockComment = function() { + var cursor = this.getCursorPosition(); + var state = this.session.getState(cursor.row); + var range = this.getSelectionRange(); + this.session.getMode().toggleBlockComment(state, this.session, range, cursor); + }; + this.getNumberAt = function(row, column) { + var _numberRx = /[\-]?[0-9]+(?:\.[0-9]+)?/g; + _numberRx.lastIndex = 0; + + var s = this.session.getLine(row); + while (_numberRx.lastIndex < column) { + var m = _numberRx.exec(s); + if(m.index <= column && m.index+m[0].length >= column){ + var number = { + value: m[0], + start: m.index, + end: m.index+m[0].length + }; + return number; + } + } + return null; + }; + this.modifyNumber = function(amount) { + var row = this.selection.getCursor().row; + var column = this.selection.getCursor().column; + var charRange = new Range(row, column-1, row, column); + + var c = this.session.getTextRange(charRange); + if (!isNaN(parseFloat(c)) && isFinite(c)) { + var nr = this.getNumberAt(row, column); + if (nr) { + var fp = nr.value.indexOf(".") >= 0 ? nr.start + nr.value.indexOf(".") + 1 : nr.end; + var decimals = nr.start + nr.value.length - fp; + + var t = parseFloat(nr.value); + t *= Math.pow(10, decimals); + + + if(fp !== nr.end && column < fp){ + amount *= Math.pow(10, nr.end - column - 1); + } else { + amount *= Math.pow(10, nr.end - column); + } + + t += amount; + t /= Math.pow(10, decimals); + var nnr = t.toFixed(decimals); + var replaceRange = new Range(row, nr.start, row, nr.end); + this.session.replace(replaceRange, nnr); + this.moveCursorTo(row, Math.max(nr.start +1, column + nnr.length - nr.value.length)); + + } + } else { + this.toggleWord(); + } + }; + + this.$toggleWordPairs = [ + ["first", "last"], + ["true", "false"], + ["yes", "no"], + ["width", "height"], + ["top", "bottom"], + ["right", "left"], + ["on", "off"], + ["x", "y"], + ["get", "set"], + ["max", "min"], + ["horizontal", "vertical"], + ["show", "hide"], + ["add", "remove"], + ["up", "down"], + ["before", "after"], + ["even", "odd"], + ["in", "out"], + ["inside", "outside"], + ["next", "previous"], + ["increase", "decrease"], + ["attach", "detach"], + ["&&", "||"], + ["==", "!="] + ]; + + this.toggleWord = function () { + var row = this.selection.getCursor().row; + var column = this.selection.getCursor().column; + this.selection.selectWord(); + var currentState = this.getSelectedText(); + var currWordStart = this.selection.getWordRange().start.column; + var wordParts = currentState.replace(/([a-z]+|[A-Z]+)(?=[A-Z_]|$)/g, '$1 ').split(/\s/); + var delta = column - currWordStart - 1; + if (delta < 0) delta = 0; + var curLength = 0, itLength = 0; + var that = this; + if (currentState.match(/[A-Za-z0-9_]+/)) { + wordParts.forEach(function (item, i) { + itLength = curLength + item.length; + if (delta >= curLength && delta <= itLength) { + currentState = item; + that.selection.clearSelection(); + that.moveCursorTo(row, curLength + currWordStart); + that.selection.selectTo(row, itLength + currWordStart); + } + curLength = itLength; + }); + } + + var wordPairs = this.$toggleWordPairs; + var reg; + for (var i = 0; i < wordPairs.length; i++) { + var item = wordPairs[i]; + for (var j = 0; j <= 1; j++) { + var negate = +!j; + var firstCondition = currentState.match(new RegExp('^\\s?_?(' + lang.escapeRegExp(item[j]) + ')\\s?$', 'i')); + if (firstCondition) { + var secondCondition = currentState.match(new RegExp('([_]|^|\\s)(' + lang.escapeRegExp(firstCondition[1]) + ')($|\\s)', 'g')); + if (secondCondition) { + reg = currentState.replace(new RegExp(lang.escapeRegExp(item[j]), 'i'), function (result) { + var res = item[negate]; + if (result.toUpperCase() == result) { + res = res.toUpperCase(); + } else if (result.charAt(0).toUpperCase() == result.charAt(0)) { + res = res.substr(0, 0) + item[negate].charAt(0).toUpperCase() + res.substr(1); + } + return res; + }); + this.insert(reg); + reg = ""; + } + } + } + } + }; + this.removeLines = function() { + var rows = this.$getSelectedRows(); + this.session.removeFullLines(rows.first, rows.last); + this.clearSelection(); + }; + + this.duplicateSelection = function() { + var sel = this.selection; + var doc = this.session; + var range = sel.getRange(); + var reverse = sel.isBackwards(); + if (range.isEmpty()) { + var row = range.start.row; + doc.duplicateLines(row, row); + } else { + var point = reverse ? range.start : range.end; + var endPoint = doc.insert(point, doc.getTextRange(range), false); + range.start = point; + range.end = endPoint; + + sel.setSelectionRange(range, reverse); + } + }; + this.moveLinesDown = function() { + this.$moveLines(1, false); + }; + this.moveLinesUp = function() { + this.$moveLines(-1, false); + }; + this.moveText = function(range, toPosition, copy) { + return this.session.moveText(range, toPosition, copy); + }; + this.copyLinesUp = function() { + this.$moveLines(-1, true); + }; + this.copyLinesDown = function() { + this.$moveLines(1, true); + }; + this.$moveLines = function(dir, copy) { + var rows, moved; + var selection = this.selection; + if (!selection.inMultiSelectMode || this.inVirtualSelectionMode) { + var range = selection.toOrientedRange(); + rows = this.$getSelectedRows(range); + moved = this.session.$moveLines(rows.first, rows.last, copy ? 0 : dir); + if (copy && dir == -1) moved = 0; + range.moveBy(moved, 0); + selection.fromOrientedRange(range); + } else { + var ranges = selection.rangeList.ranges; + selection.rangeList.detach(this.session); + this.inVirtualSelectionMode = true; + + var diff = 0; + var totalDiff = 0; + var l = ranges.length; + for (var i = 0; i < l; i++) { + var rangeIndex = i; + ranges[i].moveBy(diff, 0); + rows = this.$getSelectedRows(ranges[i]); + var first = rows.first; + var last = rows.last; + while (++i < l) { + if (totalDiff) ranges[i].moveBy(totalDiff, 0); + var subRows = this.$getSelectedRows(ranges[i]); + if (copy && subRows.first != last) + break; + else if (!copy && subRows.first > last + 1) + break; + last = subRows.last; + } + i--; + diff = this.session.$moveLines(first, last, copy ? 0 : dir); + if (copy && dir == -1) rangeIndex = i + 1; + while (rangeIndex <= i) { + ranges[rangeIndex].moveBy(diff, 0); + rangeIndex++; + } + if (!copy) diff = 0; + totalDiff += diff; + } + + selection.fromOrientedRange(selection.ranges[0]); + selection.rangeList.attach(this.session); + this.inVirtualSelectionMode = false; + } + }; + this.$getSelectedRows = function(range) { + range = (range || this.getSelectionRange()).collapseRows(); + + return { + first: this.session.getRowFoldStart(range.start.row), + last: this.session.getRowFoldEnd(range.end.row) + }; + }; + + this.onCompositionStart = function(compositionState) { + this.renderer.showComposition(compositionState); + }; + + this.onCompositionUpdate = function(text) { + this.renderer.setCompositionText(text); + }; + + this.onCompositionEnd = function() { + this.renderer.hideComposition(); + }; + this.getFirstVisibleRow = function() { + return this.renderer.getFirstVisibleRow(); + }; + this.getLastVisibleRow = function() { + return this.renderer.getLastVisibleRow(); + }; + this.isRowVisible = function(row) { + return (row >= this.getFirstVisibleRow() && row <= this.getLastVisibleRow()); + }; + this.isRowFullyVisible = function(row) { + return (row >= this.renderer.getFirstFullyVisibleRow() && row <= this.renderer.getLastFullyVisibleRow()); + }; + this.$getVisibleRowCount = function() { + return this.renderer.getScrollBottomRow() - this.renderer.getScrollTopRow() + 1; + }; + + this.$moveByPage = function(dir, select) { + var renderer = this.renderer; + var config = this.renderer.layerConfig; + var rows = dir * Math.floor(config.height / config.lineHeight); + + if (select === true) { + this.selection.$moveSelection(function(){ + this.moveCursorBy(rows, 0); + }); + } else if (select === false) { + this.selection.moveCursorBy(rows, 0); + this.selection.clearSelection(); + } + + var scrollTop = renderer.scrollTop; + + renderer.scrollBy(0, rows * config.lineHeight); + if (select != null) + renderer.scrollCursorIntoView(null, 0.5); + + renderer.animateScrolling(scrollTop); + }; + this.selectPageDown = function() { + this.$moveByPage(1, true); + }; + this.selectPageUp = function() { + this.$moveByPage(-1, true); + }; + this.gotoPageDown = function() { + this.$moveByPage(1, false); + }; + this.gotoPageUp = function() { + this.$moveByPage(-1, false); + }; + this.scrollPageDown = function() { + this.$moveByPage(1); + }; + this.scrollPageUp = function() { + this.$moveByPage(-1); + }; + this.scrollToRow = function(row) { + this.renderer.scrollToRow(row); + }; + this.scrollToLine = function(line, center, animate, callback) { + this.renderer.scrollToLine(line, center, animate, callback); + }; + this.centerSelection = function() { + var range = this.getSelectionRange(); + var pos = { + row: Math.floor(range.start.row + (range.end.row - range.start.row) / 2), + column: Math.floor(range.start.column + (range.end.column - range.start.column) / 2) + }; + this.renderer.alignCursor(pos, 0.5); + }; + this.getCursorPosition = function() { + return this.selection.getCursor(); + }; + this.getCursorPositionScreen = function() { + return this.session.documentToScreenPosition(this.getCursorPosition()); + }; + this.getSelectionRange = function() { + return this.selection.getRange(); + }; + this.selectAll = function() { + this.selection.selectAll(); + }; + this.clearSelection = function() { + this.selection.clearSelection(); + }; + this.moveCursorTo = function(row, column) { + this.selection.moveCursorTo(row, column); + }; + this.moveCursorToPosition = function(pos) { + this.selection.moveCursorToPosition(pos); + }; + this.jumpToMatching = function(select, expand) { + var cursor = this.getCursorPosition(); + var iterator = new TokenIterator(this.session, cursor.row, cursor.column); + var prevToken = iterator.getCurrentToken(); + var token = prevToken || iterator.stepForward(); + + if (!token) return; + var matchType; + var found = false; + var depth = {}; + var i = cursor.column - token.start; + var bracketType; + var brackets = { + ")": "(", + "(": "(", + "]": "[", + "[": "[", + "{": "{", + "}": "{" + }; + + do { + if (token.value.match(/[{}()\[\]]/g)) { + for (; i < token.value.length && !found; i++) { + if (!brackets[token.value[i]]) { + continue; + } + + bracketType = brackets[token.value[i]] + '.' + token.type.replace("rparen", "lparen"); + + if (isNaN(depth[bracketType])) { + depth[bracketType] = 0; + } + + switch (token.value[i]) { + case '(': + case '[': + case '{': + depth[bracketType]++; + break; + case ')': + case ']': + case '}': + depth[bracketType]--; + + if (depth[bracketType] === -1) { + matchType = 'bracket'; + found = true; + } + break; + } + } + } + else if (token.type.indexOf('tag-name') !== -1) { + if (isNaN(depth[token.value])) { + depth[token.value] = 0; + } + + if (prevToken.value === '<') { + depth[token.value]++; + } + else if (prevToken.value === '= 0; --i) { + if(this.$tryReplace(ranges[i], replacement)) { + replaced++; + } + } + + this.selection.setSelectionRange(selection); + + return replaced; + }; + + this.$tryReplace = function(range, replacement) { + var input = this.session.getTextRange(range); + replacement = this.$search.replace(input, replacement); + if (replacement !== null) { + range.end = this.session.replace(range, replacement); + return range; + } else { + return null; + } + }; + this.getLastSearchOptions = function() { + return this.$search.getOptions(); + }; + this.find = function(needle, options, animate) { + if (!options) + options = {}; + + if (typeof needle == "string" || needle instanceof RegExp) + options.needle = needle; + else if (typeof needle == "object") + oop.mixin(options, needle); + + var range = this.selection.getRange(); + if (options.needle == null) { + needle = this.session.getTextRange(range) + || this.$search.$options.needle; + if (!needle) { + range = this.session.getWordRange(range.start.row, range.start.column); + needle = this.session.getTextRange(range); + } + this.$search.set({needle: needle}); + } + + this.$search.set(options); + if (!options.start) + this.$search.set({start: range}); + + var newRange = this.$search.find(this.session); + if (options.preventScroll) + return newRange; + if (newRange) { + this.revealRange(newRange, animate); + return newRange; + } + if (options.backwards) + range.start = range.end; + else + range.end = range.start; + this.selection.setRange(range); + }; + this.findNext = function(options, animate) { + this.find({skipCurrent: true, backwards: false}, options, animate); + }; + this.findPrevious = function(options, animate) { + this.find(options, {skipCurrent: true, backwards: true}, animate); + }; + + this.revealRange = function(range, animate) { + this.session.unfold(range); + this.selection.setSelectionRange(range); + + var scrollTop = this.renderer.scrollTop; + this.renderer.scrollSelectionIntoView(range.start, range.end, 0.5); + if (animate !== false) + this.renderer.animateScrolling(scrollTop); + }; + this.undo = function() { + this.session.getUndoManager().undo(this.session); + this.renderer.scrollCursorIntoView(null, 0.5); + }; + this.redo = function() { + this.session.getUndoManager().redo(this.session); + this.renderer.scrollCursorIntoView(null, 0.5); + }; + this.destroy = function() { + if (this.$toDestroy) { + this.$toDestroy.forEach(function(el) { + el.destroy(); + }); + this.$toDestroy = null; + } + if (this.$mouseHandler) + this.$mouseHandler.destroy(); + this.renderer.destroy(); + this._signal("destroy", this); + if (this.session) + this.session.destroy(); + if (this._$emitInputEvent) + this._$emitInputEvent.cancel(); + this.removeAllListeners(); + }; + this.setAutoScrollEditorIntoView = function(enable) { + if (!enable) + return; + var rect; + var self = this; + var shouldScroll = false; + if (!this.$scrollAnchor) + this.$scrollAnchor = document.createElement("div"); + var scrollAnchor = this.$scrollAnchor; + scrollAnchor.style.cssText = "position:absolute"; + this.container.insertBefore(scrollAnchor, this.container.firstChild); + var onChangeSelection = this.on("changeSelection", function() { + shouldScroll = true; + }); + var onBeforeRender = this.renderer.on("beforeRender", function() { + if (shouldScroll) + rect = self.renderer.container.getBoundingClientRect(); + }); + var onAfterRender = this.renderer.on("afterRender", function() { + if (shouldScroll && rect && (self.isFocused() + || self.searchBox && self.searchBox.isFocused()) + ) { + var renderer = self.renderer; + var pos = renderer.$cursorLayer.$pixelPos; + var config = renderer.layerConfig; + var top = pos.top - config.offset; + if (pos.top >= 0 && top + rect.top < 0) { + shouldScroll = true; + } else if (pos.top < config.height && + pos.top + rect.top + config.lineHeight > window.innerHeight) { + shouldScroll = false; + } else { + shouldScroll = null; + } + if (shouldScroll != null) { + scrollAnchor.style.top = top + "px"; + scrollAnchor.style.left = pos.left + "px"; + scrollAnchor.style.height = config.lineHeight + "px"; + scrollAnchor.scrollIntoView(shouldScroll); + } + shouldScroll = rect = null; + } + }); + this.setAutoScrollEditorIntoView = function(enable) { + if (enable) + return; + delete this.setAutoScrollEditorIntoView; + this.off("changeSelection", onChangeSelection); + this.renderer.off("afterRender", onAfterRender); + this.renderer.off("beforeRender", onBeforeRender); + }; + }; + + + this.$resetCursorStyle = function() { + var style = this.$cursorStyle || "ace"; + var cursorLayer = this.renderer.$cursorLayer; + if (!cursorLayer) + return; + cursorLayer.setSmoothBlinking(/smooth/.test(style)); + cursorLayer.isBlinking = !this.$readOnly && style != "wide"; + dom.setCssClass(cursorLayer.element, "ace_slim-cursors", /slim/.test(style)); + }; + this.prompt = function(message, options, callback) { + var editor = this; + config.loadModule("./ext/prompt", function (module) { + module.prompt(editor, message, options, callback); + }); + }; + +}).call(Editor.prototype); + + + +config.defineOptions(Editor.prototype, "editor", { + selectionStyle: { + set: function(style) { + this.onSelectionChange(); + this._signal("changeSelectionStyle", {data: style}); + }, + initialValue: "line" + }, + highlightActiveLine: { + set: function() {this.$updateHighlightActiveLine();}, + initialValue: true + }, + highlightSelectedWord: { + set: function(shouldHighlight) {this.$onSelectionChange();}, + initialValue: true + }, + readOnly: { + set: function(readOnly) { + this.textInput.setReadOnly(readOnly); + this.$resetCursorStyle(); + }, + initialValue: false + }, + copyWithEmptySelection: { + set: function(value) { + this.textInput.setCopyWithEmptySelection(value); + }, + initialValue: false + }, + cursorStyle: { + set: function(val) { this.$resetCursorStyle(); }, + values: ["ace", "slim", "smooth", "wide"], + initialValue: "ace" + }, + mergeUndoDeltas: { + values: [false, true, "always"], + initialValue: true + }, + behavioursEnabled: {initialValue: true}, + wrapBehavioursEnabled: {initialValue: true}, + enableAutoIndent: {initialValue: true}, + autoScrollEditorIntoView: { + set: function(val) {this.setAutoScrollEditorIntoView(val);} + }, + keyboardHandler: { + set: function(val) { this.setKeyboardHandler(val); }, + get: function() { return this.$keybindingId; }, + handlesSet: true + }, + value: { + set: function(val) { this.session.setValue(val); }, + get: function() { return this.getValue(); }, + handlesSet: true, + hidden: true + }, + session: { + set: function(val) { this.setSession(val); }, + get: function() { return this.session; }, + handlesSet: true, + hidden: true + }, + + showLineNumbers: { + set: function(show) { + this.renderer.$gutterLayer.setShowLineNumbers(show); + this.renderer.$loop.schedule(this.renderer.CHANGE_GUTTER); + if (show && this.$relativeLineNumbers) + relativeNumberRenderer.attach(this); + else + relativeNumberRenderer.detach(this); + }, + initialValue: true + }, + relativeLineNumbers: { + set: function(value) { + if (this.$showLineNumbers && value) + relativeNumberRenderer.attach(this); + else + relativeNumberRenderer.detach(this); + } + }, + placeholder: { + set: function(message) { + if (!this.$updatePlaceholder) { + this.$updatePlaceholder = function() { + var value = this.session && (this.renderer.$composition || this.getValue()); + if (value && this.renderer.placeholderNode) { + this.renderer.off("afterRender", this.$updatePlaceholder); + dom.removeCssClass(this.container, "ace_hasPlaceholder"); + this.renderer.placeholderNode.remove(); + this.renderer.placeholderNode = null; + } else if (!value && !this.renderer.placeholderNode) { + this.renderer.on("afterRender", this.$updatePlaceholder); + dom.addCssClass(this.container, "ace_hasPlaceholder"); + var el = dom.createElement("div"); + el.className = "ace_placeholder"; + el.textContent = this.$placeholder || ""; + this.renderer.placeholderNode = el; + this.renderer.content.appendChild(this.renderer.placeholderNode); + } else if (!value && this.renderer.placeholderNode) { + this.renderer.placeholderNode.textContent = this.$placeholder || ""; + } + }.bind(this); + this.on("input", this.$updatePlaceholder); + } + this.$updatePlaceholder(); + } + }, + + hScrollBarAlwaysVisible: "renderer", + vScrollBarAlwaysVisible: "renderer", + highlightGutterLine: "renderer", + animatedScroll: "renderer", + showInvisibles: "renderer", + showPrintMargin: "renderer", + printMarginColumn: "renderer", + printMargin: "renderer", + fadeFoldWidgets: "renderer", + showFoldWidgets: "renderer", + displayIndentGuides: "renderer", + showGutter: "renderer", + fontSize: "renderer", + fontFamily: "renderer", + maxLines: "renderer", + minLines: "renderer", + scrollPastEnd: "renderer", + fixedWidthGutter: "renderer", + theme: "renderer", + hasCssTransforms: "renderer", + maxPixelHeight: "renderer", + useTextareaForIME: "renderer", + + scrollSpeed: "$mouseHandler", + dragDelay: "$mouseHandler", + dragEnabled: "$mouseHandler", + focusTimeout: "$mouseHandler", + tooltipFollowsMouse: "$mouseHandler", + + firstLineNumber: "session", + overwrite: "session", + newLineMode: "session", + useWorker: "session", + useSoftTabs: "session", + navigateWithinSoftTabs: "session", + tabSize: "session", + wrap: "session", + indentedSoftWrap: "session", + foldStyle: "session", + mode: "session" +}); + + +var relativeNumberRenderer = { + getText: function(session, row) { + return (Math.abs(session.selection.lead.row - row) || (row + 1 + (row < 9 ? "\xb7" : ""))) + ""; + }, + getWidth: function(session, lastLineNumber, config) { + return Math.max( + lastLineNumber.toString().length, + (config.lastRow + 1).toString().length, + 2 + ) * config.characterWidth; + }, + update: function(e, editor) { + editor.renderer.$loop.schedule(editor.renderer.CHANGE_GUTTER); + }, + attach: function(editor) { + editor.renderer.$gutterLayer.$renderer = this; + editor.on("changeSelection", this.update); + this.update(null, editor); + }, + detach: function(editor) { + if (editor.renderer.$gutterLayer.$renderer == this) + editor.renderer.$gutterLayer.$renderer = null; + editor.off("changeSelection", this.update); + this.update(null, editor); + } +}; + +exports.Editor = Editor; +}); + +ace.define("ace/undomanager",["require","exports","module","ace/range"], function(require, exports, module) { +"use strict"; +var UndoManager = function() { + this.$maxRev = 0; + this.$fromUndo = false; + this.reset(); +}; + +(function() { + + this.addSession = function(session) { + this.$session = session; + }; + this.add = function(delta, allowMerge, session) { + if (this.$fromUndo) return; + if (delta == this.$lastDelta) return; + if (!this.$keepRedoStack) this.$redoStack.length = 0; + if (allowMerge === false || !this.lastDeltas) { + this.lastDeltas = []; + this.$undoStack.push(this.lastDeltas); + delta.id = this.$rev = ++this.$maxRev; + } + if (delta.action == "remove" || delta.action == "insert") + this.$lastDelta = delta; + this.lastDeltas.push(delta); + }; + + this.addSelection = function(selection, rev) { + this.selections.push({ + value: selection, + rev: rev || this.$rev + }); + }; + + this.startNewGroup = function() { + this.lastDeltas = null; + return this.$rev; + }; + + this.markIgnored = function(from, to) { + if (to == null) to = this.$rev + 1; + var stack = this.$undoStack; + for (var i = stack.length; i--;) { + var delta = stack[i][0]; + if (delta.id <= from) + break; + if (delta.id < to) + delta.ignore = true; + } + this.lastDeltas = null; + }; + + this.getSelection = function(rev, after) { + var stack = this.selections; + for (var i = stack.length; i--;) { + var selection = stack[i]; + if (selection.rev < rev) { + if (after) + selection = stack[i + 1]; + return selection; + } + } + }; + + this.getRevision = function() { + return this.$rev; + }; + + this.getDeltas = function(from, to) { + if (to == null) to = this.$rev + 1; + var stack = this.$undoStack; + var end = null, start = 0; + for (var i = stack.length; i--;) { + var delta = stack[i][0]; + if (delta.id < to && !end) + end = i+1; + if (delta.id <= from) { + start = i + 1; + break; + } + } + return stack.slice(start, end); + }; + + this.getChangedRanges = function(from, to) { + if (to == null) to = this.$rev + 1; + + }; + + this.getChangedLines = function(from, to) { + if (to == null) to = this.$rev + 1; + + }; + this.undo = function(session, dontSelect) { + this.lastDeltas = null; + var stack = this.$undoStack; + + if (!rearrangeUndoStack(stack, stack.length)) + return; + + if (!session) + session = this.$session; + + if (this.$redoStackBaseRev !== this.$rev && this.$redoStack.length) + this.$redoStack = []; + + this.$fromUndo = true; + + var deltaSet = stack.pop(); + var undoSelectionRange = null; + if (deltaSet) { + undoSelectionRange = session.undoChanges(deltaSet, dontSelect); + this.$redoStack.push(deltaSet); + this.$syncRev(); + } + + this.$fromUndo = false; + + return undoSelectionRange; + }; + this.redo = function(session, dontSelect) { + this.lastDeltas = null; + + if (!session) + session = this.$session; + + this.$fromUndo = true; + if (this.$redoStackBaseRev != this.$rev) { + var diff = this.getDeltas(this.$redoStackBaseRev, this.$rev + 1); + rebaseRedoStack(this.$redoStack, diff); + this.$redoStackBaseRev = this.$rev; + this.$redoStack.forEach(function(x) { + x[0].id = ++this.$maxRev; + }, this); + } + var deltaSet = this.$redoStack.pop(); + var redoSelectionRange = null; + + if (deltaSet) { + redoSelectionRange = session.redoChanges(deltaSet, dontSelect); + this.$undoStack.push(deltaSet); + this.$syncRev(); + } + this.$fromUndo = false; + + return redoSelectionRange; + }; + + this.$syncRev = function() { + var stack = this.$undoStack; + var nextDelta = stack[stack.length - 1]; + var id = nextDelta && nextDelta[0].id || 0; + this.$redoStackBaseRev = id; + this.$rev = id; + }; + this.reset = function() { + this.lastDeltas = null; + this.$lastDelta = null; + this.$undoStack = []; + this.$redoStack = []; + this.$rev = 0; + this.mark = 0; + this.$redoStackBaseRev = this.$rev; + this.selections = []; + }; + this.canUndo = function() { + return this.$undoStack.length > 0; + }; + this.canRedo = function() { + return this.$redoStack.length > 0; + }; + this.bookmark = function(rev) { + if (rev == undefined) + rev = this.$rev; + this.mark = rev; + }; + this.isAtBookmark = function() { + return this.$rev === this.mark; + }; + + this.toJSON = function() { + + }; + + this.fromJSON = function() { + + }; + + this.hasUndo = this.canUndo; + this.hasRedo = this.canRedo; + this.isClean = this.isAtBookmark; + this.markClean = this.bookmark; + + this.$prettyPrint = function(delta) { + if (delta) return stringifyDelta(delta); + return stringifyDelta(this.$undoStack) + "\n---\n" + stringifyDelta(this.$redoStack); + }; +}).call(UndoManager.prototype); + +function rearrangeUndoStack(stack, pos) { + for (var i = pos; i--; ) { + var deltaSet = stack[i]; + if (deltaSet && !deltaSet[0].ignore) { + while(i < pos - 1) { + var swapped = swapGroups(stack[i], stack[i + 1]); + stack[i] = swapped[0]; + stack[i + 1] = swapped[1]; + i++; + } + return true; + } + } +} + +var Range = require("./range").Range; +var cmp = Range.comparePoints; +var comparePoints = Range.comparePoints; + +function $updateMarkers(delta) { + var isInsert = delta.action == "insert"; + var start = delta.start; + var end = delta.end; + var rowShift = (end.row - start.row) * (isInsert ? 1 : -1); + var colShift = (end.column - start.column) * (isInsert ? 1 : -1); + if (isInsert) end = start; + + for (var i in this.marks) { + var point = this.marks[i]; + var cmp = comparePoints(point, start); + if (cmp < 0) { + continue; // delta starts after the range + } + if (cmp === 0) { + if (isInsert) { + if (point.bias == 1) { + cmp = 1; + } + else { + point.bias == -1; + continue; + } + } + } + var cmp2 = isInsert ? cmp : comparePoints(point, end); + if (cmp2 > 0) { + point.row += rowShift; + point.column += point.row == end.row ? colShift : 0; + continue; + } + if (!isInsert && cmp2 <= 0) { + point.row = start.row; + point.column = start.column; + if (cmp2 === 0) + point.bias = 1; + } + } +} + + + +function clonePos(pos) { + return {row: pos.row,column: pos.column}; +} +function cloneDelta(d) { + return { + start: clonePos(d.start), + end: clonePos(d.end), + action: d.action, + lines: d.lines.slice() + }; +} +function stringifyDelta(d) { + d = d || this; + if (Array.isArray(d)) { + return d.map(stringifyDelta).join("\n"); + } + var type = ""; + if (d.action) { + type = d.action == "insert" ? "+" : "-"; + type += "[" + d.lines + "]"; + } else if (d.value) { + if (Array.isArray(d.value)) { + type = d.value.map(stringifyRange).join("\n"); + } else { + type = stringifyRange(d.value); + } + } + if (d.start) { + type += stringifyRange(d); + } + if (d.id || d.rev) { + type += "\t(" + (d.id || d.rev) + ")"; + } + return type; +} +function stringifyRange(r) { + return r.start.row + ":" + r.start.column + + "=>" + r.end.row + ":" + r.end.column; +} + +function swap(d1, d2) { + var i1 = d1.action == "insert"; + var i2 = d2.action == "insert"; + + if (i1 && i2) { + if (cmp(d2.start, d1.end) >= 0) { + shift(d2, d1, -1); + } else if (cmp(d2.start, d1.start) <= 0) { + shift(d1, d2, +1); + } else { + return null; + } + } else if (i1 && !i2) { + if (cmp(d2.start, d1.end) >= 0) { + shift(d2, d1, -1); + } else if (cmp(d2.end, d1.start) <= 0) { + shift(d1, d2, -1); + } else { + return null; + } + } else if (!i1 && i2) { + if (cmp(d2.start, d1.start) >= 0) { + shift(d2, d1, +1); + } else if (cmp(d2.start, d1.start) <= 0) { + shift(d1, d2, +1); + } else { + return null; + } + } else if (!i1 && !i2) { + if (cmp(d2.start, d1.start) >= 0) { + shift(d2, d1, +1); + } else if (cmp(d2.end, d1.start) <= 0) { + shift(d1, d2, -1); + } else { + return null; + } + } + return [d2, d1]; +} +function swapGroups(ds1, ds2) { + for (var i = ds1.length; i--; ) { + for (var j = 0; j < ds2.length; j++) { + if (!swap(ds1[i], ds2[j])) { + while (i < ds1.length) { + while (j--) { + swap(ds2[j], ds1[i]); + } + j = ds2.length; + i++; + } + return [ds1, ds2]; + } + } + } + ds1.selectionBefore = ds2.selectionBefore = + ds1.selectionAfter = ds2.selectionAfter = null; + return [ds2, ds1]; +} +function xform(d1, c1) { + var i1 = d1.action == "insert"; + var i2 = c1.action == "insert"; + + if (i1 && i2) { + if (cmp(d1.start, c1.start) < 0) { + shift(c1, d1, 1); + } else { + shift(d1, c1, 1); + } + } else if (i1 && !i2) { + if (cmp(d1.start, c1.end) >= 0) { + shift(d1, c1, -1); + } else if (cmp(d1.start, c1.start) <= 0) { + shift(c1, d1, +1); + } else { + shift(d1, Range.fromPoints(c1.start, d1.start), -1); + shift(c1, d1, +1); + } + } else if (!i1 && i2) { + if (cmp(c1.start, d1.end) >= 0) { + shift(c1, d1, -1); + } else if (cmp(c1.start, d1.start) <= 0) { + shift(d1, c1, +1); + } else { + shift(c1, Range.fromPoints(d1.start, c1.start), -1); + shift(d1, c1, +1); + } + } else if (!i1 && !i2) { + if (cmp(c1.start, d1.end) >= 0) { + shift(c1, d1, -1); + } else if (cmp(c1.end, d1.start) <= 0) { + shift(d1, c1, -1); + } else { + var before, after; + if (cmp(d1.start, c1.start) < 0) { + before = d1; + d1 = splitDelta(d1, c1.start); + } + if (cmp(d1.end, c1.end) > 0) { + after = splitDelta(d1, c1.end); + } + + shiftPos(c1.end, d1.start, d1.end, -1); + if (after && !before) { + d1.lines = after.lines; + d1.start = after.start; + d1.end = after.end; + after = d1; + } + + return [c1, before, after].filter(Boolean); + } + } + return [c1, d1]; +} + +function shift(d1, d2, dir) { + shiftPos(d1.start, d2.start, d2.end, dir); + shiftPos(d1.end, d2.start, d2.end, dir); +} +function shiftPos(pos, start, end, dir) { + if (pos.row == (dir == 1 ? start : end).row) { + pos.column += dir * (end.column - start.column); + } + pos.row += dir * (end.row - start.row); +} +function splitDelta(c, pos) { + var lines = c.lines; + var end = c.end; + c.end = clonePos(pos); + var rowsBefore = c.end.row - c.start.row; + var otherLines = lines.splice(rowsBefore, lines.length); + + var col = rowsBefore ? pos.column : pos.column - c.start.column; + lines.push(otherLines[0].substring(0, col)); + otherLines[0] = otherLines[0].substr(col) ; + var rest = { + start: clonePos(pos), + end: end, + lines: otherLines, + action: c.action + }; + return rest; +} + +function moveDeltasByOne(redoStack, d) { + d = cloneDelta(d); + for (var j = redoStack.length; j--;) { + var deltaSet = redoStack[j]; + for (var i = 0; i < deltaSet.length; i++) { + var x = deltaSet[i]; + var xformed = xform(x, d); + d = xformed[0]; + if (xformed.length != 2) { + if (xformed[2]) { + deltaSet.splice(i + 1, 1, xformed[1], xformed[2]); + i++; + } else if (!xformed[1]) { + deltaSet.splice(i, 1); + i--; + } + } + } + if (!deltaSet.length) { + redoStack.splice(j, 1); + } + } + return redoStack; +} +function rebaseRedoStack(redoStack, deltaSets) { + for (var i = 0; i < deltaSets.length; i++) { + var deltas = deltaSets[i]; + for (var j = 0; j < deltas.length; j++) { + moveDeltasByOne(redoStack, deltas[j]); + } + } +} + +exports.UndoManager = UndoManager; + +}); + +ace.define("ace/layer/lines",["require","exports","module","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var dom = require("../lib/dom"); + +var Lines = function(element, canvasHeight) { + this.element = element; + this.canvasHeight = canvasHeight || 500000; + this.element.style.height = (this.canvasHeight * 2) + "px"; + + this.cells = []; + this.cellCache = []; + this.$offsetCoefficient = 0; +}; + +(function() { + + this.moveContainer = function(config) { + dom.translate(this.element, 0, -((config.firstRowScreen * config.lineHeight) % this.canvasHeight) - config.offset * this.$offsetCoefficient); + }; + + this.pageChanged = function(oldConfig, newConfig) { + return ( + Math.floor((oldConfig.firstRowScreen * oldConfig.lineHeight) / this.canvasHeight) !== + Math.floor((newConfig.firstRowScreen * newConfig.lineHeight) / this.canvasHeight) + ); + }; + + this.computeLineTop = function(row, config, session) { + var screenTop = config.firstRowScreen * config.lineHeight; + var screenPage = Math.floor(screenTop / this.canvasHeight); + var lineTop = session.documentToScreenRow(row, 0) * config.lineHeight; + return lineTop - (screenPage * this.canvasHeight); + }; + + this.computeLineHeight = function(row, config, session) { + return config.lineHeight * session.getRowLineCount(row); + }; + + this.getLength = function() { + return this.cells.length; + }; + + this.get = function(index) { + return this.cells[index]; + }; + + this.shift = function() { + this.$cacheCell(this.cells.shift()); + }; + + this.pop = function() { + this.$cacheCell(this.cells.pop()); + }; + + this.push = function(cell) { + if (Array.isArray(cell)) { + this.cells.push.apply(this.cells, cell); + var fragment = dom.createFragment(this.element); + for (var i=0; i foldStart) { + row = fold.end.row + 1; + fold = session.getNextFoldLine(row, fold); + foldStart = fold ? fold.start.row : Infinity; + } + if (row > lastRow) { + while (this.$lines.getLength() > index + 1) + this.$lines.pop(); + + break; + } + + cell = this.$lines.get(++index); + if (cell) { + cell.row = row; + } else { + cell = this.$lines.createCell(row, config, this.session, onCreateCell); + this.$lines.push(cell); + } + + this.$renderCell(cell, config, fold, row); + row++; + } + + this._signal("afterRender"); + this.$updateGutterWidth(config); + }; + + this.$updateGutterWidth = function(config) { + var session = this.session; + + var gutterRenderer = session.gutterRenderer || this.$renderer; + + var firstLineNumber = session.$firstLineNumber; + var lastLineText = this.$lines.last() ? this.$lines.last().text : ""; + + if (this.$fixedWidth || session.$useWrapMode) + lastLineText = session.getLength() + firstLineNumber - 1; + + var gutterWidth = gutterRenderer + ? gutterRenderer.getWidth(session, lastLineText, config) + : lastLineText.toString().length * config.characterWidth; + + var padding = this.$padding || this.$computePadding(); + gutterWidth += padding.left + padding.right; + if (gutterWidth !== this.gutterWidth && !isNaN(gutterWidth)) { + this.gutterWidth = gutterWidth; + this.element.parentNode.style.width = + this.element.style.width = Math.ceil(this.gutterWidth) + "px"; + this._signal("changeGutterWidth", gutterWidth); + } + }; + + this.$updateCursorRow = function() { + if (!this.$highlightGutterLine) + return; + + var position = this.session.selection.getCursor(); + if (this.$cursorRow === position.row) + return; + + this.$cursorRow = position.row; + }; + + this.updateLineHighlight = function() { + if (!this.$highlightGutterLine) + return; + var row = this.session.selection.cursor.row; + this.$cursorRow = row; + + if (this.$cursorCell && this.$cursorCell.row == row) + return; + if (this.$cursorCell) + this.$cursorCell.element.className = this.$cursorCell.element.className.replace("ace_gutter-active-line ", ""); + var cells = this.$lines.cells; + this.$cursorCell = null; + for (var i = 0; i < cells.length; i++) { + var cell = cells[i]; + if (cell.row >= this.$cursorRow) { + if (cell.row > this.$cursorRow) { + var fold = this.session.getFoldLine(this.$cursorRow); + if (i > 0 && fold && fold.start.row == cells[i - 1].row) + cell = cells[i - 1]; + else + break; + } + cell.element.className = "ace_gutter-active-line " + cell.element.className; + this.$cursorCell = cell; + break; + } + } + }; + + this.scrollLines = function(config) { + var oldConfig = this.config; + this.config = config; + + this.$updateCursorRow(); + if (this.$lines.pageChanged(oldConfig, config)) + return this.update(config); + + this.$lines.moveContainer(config); + + var lastRow = Math.min(config.lastRow + config.gutterOffset, // needed to compensate for hor scollbar + this.session.getLength() - 1); + var oldLastRow = this.oldLastRow; + this.oldLastRow = lastRow; + + if (!oldConfig || oldLastRow < config.firstRow) + return this.update(config); + + if (lastRow < oldConfig.firstRow) + return this.update(config); + + if (oldConfig.firstRow < config.firstRow) + for (var row=this.session.getFoldedRowCount(oldConfig.firstRow, config.firstRow - 1); row>0; row--) + this.$lines.shift(); + + if (oldLastRow > lastRow) + for (var row=this.session.getFoldedRowCount(lastRow + 1, oldLastRow); row>0; row--) + this.$lines.pop(); + + if (config.firstRow < oldConfig.firstRow) { + this.$lines.unshift(this.$renderLines(config, config.firstRow, oldConfig.firstRow - 1)); + } + + if (lastRow > oldLastRow) { + this.$lines.push(this.$renderLines(config, oldLastRow + 1, lastRow)); + } + + this.updateLineHighlight(); + + this._signal("afterRender"); + this.$updateGutterWidth(config); + }; + + this.$renderLines = function(config, firstRow, lastRow) { + var fragment = []; + var row = firstRow; + var foldLine = this.session.getNextFoldLine(row); + var foldStart = foldLine ? foldLine.start.row : Infinity; + + while (true) { + if (row > foldStart) { + row = foldLine.end.row+1; + foldLine = this.session.getNextFoldLine(row, foldLine); + foldStart = foldLine ? foldLine.start.row : Infinity; + } + if (row > lastRow) + break; + + var cell = this.$lines.createCell(row, config, this.session, onCreateCell); + this.$renderCell(cell, config, foldLine, row); + fragment.push(cell); + + row++; + } + return fragment; + }; + + this.$renderCell = function(cell, config, fold, row) { + var element = cell.element; + + var session = this.session; + + var textNode = element.childNodes[0]; + var foldWidget = element.childNodes[1]; + + var firstLineNumber = session.$firstLineNumber; + + var breakpoints = session.$breakpoints; + var decorations = session.$decorations; + var gutterRenderer = session.gutterRenderer || this.$renderer; + var foldWidgets = this.$showFoldWidgets && session.foldWidgets; + var foldStart = fold ? fold.start.row : Number.MAX_VALUE; + + var className = "ace_gutter-cell "; + if (this.$highlightGutterLine) { + if (row == this.$cursorRow || (fold && row < this.$cursorRow && row >= foldStart && this.$cursorRow <= fold.end.row)) { + className += "ace_gutter-active-line "; + if (this.$cursorCell != cell) { + if (this.$cursorCell) + this.$cursorCell.element.className = this.$cursorCell.element.className.replace("ace_gutter-active-line ", ""); + this.$cursorCell = cell; + } + } + } + + if (breakpoints[row]) + className += breakpoints[row]; + if (decorations[row]) + className += decorations[row]; + if (this.$annotations[row]) + className += this.$annotations[row].className; + if (element.className != className) + element.className = className; + + if (foldWidgets) { + var c = foldWidgets[row]; + if (c == null) + c = foldWidgets[row] = session.getFoldWidget(row); + } + + if (c) { + var className = "ace_fold-widget ace_" + c; + if (c == "start" && row == foldStart && row < fold.end.row) + className += " ace_closed"; + else + className += " ace_open"; + if (foldWidget.className != className) + foldWidget.className = className; + + var foldHeight = config.lineHeight + "px"; + dom.setStyle(foldWidget.style, "height", foldHeight); + dom.setStyle(foldWidget.style, "display", "inline-block"); + } else { + if (foldWidget) { + dom.setStyle(foldWidget.style, "display", "none"); + } + } + + var text = (gutterRenderer + ? gutterRenderer.getText(session, row) + : row + firstLineNumber).toString(); + + if (text !== textNode.data) { + textNode.data = text; + } + + dom.setStyle(cell.element.style, "height", this.$lines.computeLineHeight(row, config, session) + "px"); + dom.setStyle(cell.element.style, "top", this.$lines.computeLineTop(row, config, session) + "px"); + + cell.text = text; + return cell; + }; + + this.$fixedWidth = false; + + this.$highlightGutterLine = true; + this.$renderer = ""; + this.setHighlightGutterLine = function(highlightGutterLine) { + this.$highlightGutterLine = highlightGutterLine; + }; + + this.$showLineNumbers = true; + this.$renderer = ""; + this.setShowLineNumbers = function(show) { + this.$renderer = !show && { + getWidth: function() {return 0;}, + getText: function() {return "";} + }; + }; + + this.getShowLineNumbers = function() { + return this.$showLineNumbers; + }; + + this.$showFoldWidgets = true; + this.setShowFoldWidgets = function(show) { + if (show) + dom.addCssClass(this.element, "ace_folding-enabled"); + else + dom.removeCssClass(this.element, "ace_folding-enabled"); + + this.$showFoldWidgets = show; + this.$padding = null; + }; + + this.getShowFoldWidgets = function() { + return this.$showFoldWidgets; + }; + + this.$computePadding = function() { + if (!this.element.firstChild) + return {left: 0, right: 0}; + var style = dom.computedStyle(this.element.firstChild); + this.$padding = {}; + this.$padding.left = (parseInt(style.borderLeftWidth) || 0) + + (parseInt(style.paddingLeft) || 0) + 1; + this.$padding.right = (parseInt(style.borderRightWidth) || 0) + + (parseInt(style.paddingRight) || 0); + return this.$padding; + }; + + this.getRegion = function(point) { + var padding = this.$padding || this.$computePadding(); + var rect = this.element.getBoundingClientRect(); + if (point.x < padding.left + rect.left) + return "markers"; + if (this.$showFoldWidgets && point.x > rect.right - padding.right) + return "foldWidgets"; + }; + +}).call(Gutter.prototype); + +function onCreateCell(element) { + var textNode = document.createTextNode(''); + element.appendChild(textNode); + + var foldWidget = dom.createElement("span"); + element.appendChild(foldWidget); + + return element; +} + +exports.Gutter = Gutter; + +}); + +ace.define("ace/layer/marker",["require","exports","module","ace/range","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var Range = require("../range").Range; +var dom = require("../lib/dom"); + +var Marker = function(parentEl) { + this.element = dom.createElement("div"); + this.element.className = "ace_layer ace_marker-layer"; + parentEl.appendChild(this.element); +}; + +(function() { + + this.$padding = 0; + + this.setPadding = function(padding) { + this.$padding = padding; + }; + this.setSession = function(session) { + this.session = session; + }; + + this.setMarkers = function(markers) { + this.markers = markers; + }; + + this.elt = function(className, css) { + var x = this.i != -1 && this.element.childNodes[this.i]; + if (!x) { + x = document.createElement("div"); + this.element.appendChild(x); + this.i = -1; + } else { + this.i++; + } + x.style.cssText = css; + x.className = className; + }; + + this.update = function(config) { + if (!config) return; + + this.config = config; + + this.i = 0; + var html; + for (var key in this.markers) { + var marker = this.markers[key]; + + if (!marker.range) { + marker.update(html, this, this.session, config); + continue; + } + + var range = marker.range.clipRows(config.firstRow, config.lastRow); + if (range.isEmpty()) continue; + + range = range.toScreenRange(this.session); + if (marker.renderer) { + var top = this.$getTop(range.start.row, config); + var left = this.$padding + range.start.column * config.characterWidth; + marker.renderer(html, range, left, top, config); + } else if (marker.type == "fullLine") { + this.drawFullLineMarker(html, range, marker.clazz, config); + } else if (marker.type == "screenLine") { + this.drawScreenLineMarker(html, range, marker.clazz, config); + } else if (range.isMultiLine()) { + if (marker.type == "text") + this.drawTextMarker(html, range, marker.clazz, config); + else + this.drawMultiLineMarker(html, range, marker.clazz, config); + } else { + this.drawSingleLineMarker(html, range, marker.clazz + " ace_start" + " ace_br15", config); + } + } + if (this.i !=-1) { + while (this.i < this.element.childElementCount) + this.element.removeChild(this.element.lastChild); + } + }; + + this.$getTop = function(row, layerConfig) { + return (row - layerConfig.firstRowScreen) * layerConfig.lineHeight; + }; + + function getBorderClass(tl, tr, br, bl) { + return (tl ? 1 : 0) | (tr ? 2 : 0) | (br ? 4 : 0) | (bl ? 8 : 0); + } + this.drawTextMarker = function(stringBuilder, range, clazz, layerConfig, extraStyle) { + var session = this.session; + var start = range.start.row; + var end = range.end.row; + var row = start; + var prev = 0; + var curr = 0; + var next = session.getScreenLastRowColumn(row); + var lineRange = new Range(row, range.start.column, row, curr); + for (; row <= end; row++) { + lineRange.start.row = lineRange.end.row = row; + lineRange.start.column = row == start ? range.start.column : session.getRowWrapIndent(row); + lineRange.end.column = next; + prev = curr; + curr = next; + next = row + 1 < end ? session.getScreenLastRowColumn(row + 1) : row == end ? 0 : range.end.column; + this.drawSingleLineMarker(stringBuilder, lineRange, + clazz + (row == start ? " ace_start" : "") + " ace_br" + + getBorderClass(row == start || row == start + 1 && range.start.column, prev < curr, curr > next, row == end), + layerConfig, row == end ? 0 : 1, extraStyle); + } + }; + this.drawMultiLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var padding = this.$padding; + var height = config.lineHeight; + var top = this.$getTop(range.start.row, config); + var left = padding + range.start.column * config.characterWidth; + extraStyle = extraStyle || ""; + + if (this.session.$bidiHandler.isBidiRow(range.start.row)) { + var range1 = range.clone(); + range1.end.row = range1.start.row; + range1.end.column = this.session.getLine(range1.start.row).length; + this.drawBidiSingleLineMarker(stringBuilder, range1, clazz + " ace_br1 ace_start", config, null, extraStyle); + } else { + this.elt( + clazz + " ace_br1 ace_start", + "height:"+ height+ "px;"+ "right:0;"+ "top:"+top+ "px;left:"+ left+ "px;" + (extraStyle || "") + ); + } + if (this.session.$bidiHandler.isBidiRow(range.end.row)) { + var range1 = range.clone(); + range1.start.row = range1.end.row; + range1.start.column = 0; + this.drawBidiSingleLineMarker(stringBuilder, range1, clazz + " ace_br12", config, null, extraStyle); + } else { + top = this.$getTop(range.end.row, config); + var width = range.end.column * config.characterWidth; + + this.elt( + clazz + " ace_br12", + "height:"+ height+ "px;"+ + "width:"+ width+ "px;"+ + "top:"+ top+ "px;"+ + "left:"+ padding+ "px;"+ (extraStyle || "") + ); + } + height = (range.end.row - range.start.row - 1) * config.lineHeight; + if (height <= 0) + return; + top = this.$getTop(range.start.row + 1, config); + + var radiusClass = (range.start.column ? 1 : 0) | (range.end.column ? 0 : 8); + + this.elt( + clazz + (radiusClass ? " ace_br" + radiusClass : ""), + "height:"+ height+ "px;"+ + "right:0;"+ + "top:"+ top+ "px;"+ + "left:"+ padding+ "px;"+ (extraStyle || "") + ); + }; + this.drawSingleLineMarker = function(stringBuilder, range, clazz, config, extraLength, extraStyle) { + if (this.session.$bidiHandler.isBidiRow(range.start.row)) + return this.drawBidiSingleLineMarker(stringBuilder, range, clazz, config, extraLength, extraStyle); + var height = config.lineHeight; + var width = (range.end.column + (extraLength || 0) - range.start.column) * config.characterWidth; + + var top = this.$getTop(range.start.row, config); + var left = this.$padding + range.start.column * config.characterWidth; + + this.elt( + clazz, + "height:"+ height+ "px;"+ + "width:"+ width+ "px;"+ + "top:"+ top+ "px;"+ + "left:"+ left+ "px;"+ (extraStyle || "") + ); + }; + this.drawBidiSingleLineMarker = function(stringBuilder, range, clazz, config, extraLength, extraStyle) { + var height = config.lineHeight, top = this.$getTop(range.start.row, config), padding = this.$padding; + var selections = this.session.$bidiHandler.getSelections(range.start.column, range.end.column); + + selections.forEach(function(selection) { + this.elt( + clazz, + "height:" + height + "px;" + + "width:" + selection.width + (extraLength || 0) + "px;" + + "top:" + top + "px;" + + "left:" + (padding + selection.left) + "px;" + (extraStyle || "") + ); + }, this); + }; + + this.drawFullLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var top = this.$getTop(range.start.row, config); + var height = config.lineHeight; + if (range.start.row != range.end.row) + height += this.$getTop(range.end.row, config) - top; + + this.elt( + clazz, + "height:"+ height+ "px;"+ + "top:"+ top+ "px;"+ + "left:0;right:0;"+ (extraStyle || "") + ); + }; + + this.drawScreenLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var top = this.$getTop(range.start.row, config); + var height = config.lineHeight; + + this.elt( + clazz, + "height:"+ height+ "px;"+ + "top:"+ top+ "px;"+ + "left:0;right:0;"+ (extraStyle || "") + ); + }; + +}).call(Marker.prototype); + +exports.Marker = Marker; + +}); + +ace.define("ace/layer/text",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/layer/lines","ace/lib/event_emitter"], function(require, exports, module) { +"use strict"; + +var oop = require("../lib/oop"); +var dom = require("../lib/dom"); +var lang = require("../lib/lang"); +var Lines = require("./lines").Lines; +var EventEmitter = require("../lib/event_emitter").EventEmitter; + +var Text = function(parentEl) { + this.dom = dom; + this.element = this.dom.createElement("div"); + this.element.className = "ace_layer ace_text-layer"; + parentEl.appendChild(this.element); + this.$updateEolChar = this.$updateEolChar.bind(this); + this.$lines = new Lines(this.element); +}; + +(function() { + + oop.implement(this, EventEmitter); + + this.EOF_CHAR = "\xB6"; + this.EOL_CHAR_LF = "\xAC"; + this.EOL_CHAR_CRLF = "\xa4"; + this.EOL_CHAR = this.EOL_CHAR_LF; + this.TAB_CHAR = "\u2014"; //"\u21E5"; + this.SPACE_CHAR = "\xB7"; + this.$padding = 0; + this.MAX_LINE_LENGTH = 10000; + + this.$updateEolChar = function() { + var doc = this.session.doc; + var unixMode = doc.getNewLineCharacter() == "\n" && doc.getNewLineMode() != "windows"; + var EOL_CHAR = unixMode ? this.EOL_CHAR_LF : this.EOL_CHAR_CRLF; + if (this.EOL_CHAR != EOL_CHAR) { + this.EOL_CHAR = EOL_CHAR; + return true; + } + }; + + this.setPadding = function(padding) { + this.$padding = padding; + this.element.style.margin = "0 " + padding + "px"; + }; + + this.getLineHeight = function() { + return this.$fontMetrics.$characterSize.height || 0; + }; + + this.getCharacterWidth = function() { + return this.$fontMetrics.$characterSize.width || 0; + }; + + this.$setFontMetrics = function(measure) { + this.$fontMetrics = measure; + this.$fontMetrics.on("changeCharacterSize", function(e) { + this._signal("changeCharacterSize", e); + }.bind(this)); + this.$pollSizeChanges(); + }; + + this.checkForSizeChanges = function() { + this.$fontMetrics.checkForSizeChanges(); + }; + this.$pollSizeChanges = function() { + return this.$pollSizeChangesTimer = this.$fontMetrics.$pollSizeChanges(); + }; + this.setSession = function(session) { + this.session = session; + if (session) + this.$computeTabString(); + }; + + this.showInvisibles = false; + this.showSpaces = false; + this.showTabs = false; + this.showEOL = false; + this.setShowInvisibles = function(showInvisibles) { + if (this.showInvisibles == showInvisibles) + return false; + + this.showInvisibles = showInvisibles; + if (typeof showInvisibles == "string") { + this.showSpaces = /tab/i.test(showInvisibles); + this.showTabs = /space/i.test(showInvisibles); + this.showEOL = /eol/i.test(showInvisibles); + } else { + this.showSpaces = this.showTabs = this.showEOL = showInvisibles; + } + this.$computeTabString(); + return true; + }; + + this.displayIndentGuides = true; + this.setDisplayIndentGuides = function(display) { + if (this.displayIndentGuides == display) + return false; + + this.displayIndentGuides = display; + this.$computeTabString(); + return true; + }; + + this.$tabStrings = []; + this.onChangeTabSize = + this.$computeTabString = function() { + var tabSize = this.session.getTabSize(); + this.tabSize = tabSize; + var tabStr = this.$tabStrings = [0]; + for (var i = 1; i < tabSize + 1; i++) { + if (this.showTabs) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_tab"; + span.textContent = lang.stringRepeat(this.TAB_CHAR, i); + tabStr.push(span); + } else { + tabStr.push(this.dom.createTextNode(lang.stringRepeat(" ", i), this.element)); + } + } + if (this.displayIndentGuides) { + this.$indentGuideRe = /\s\S| \t|\t |\s$/; + var className = "ace_indent-guide"; + var spaceClass = this.showSpaces ? " ace_invisible ace_invisible_space" : ""; + var spaceContent = this.showSpaces + ? lang.stringRepeat(this.SPACE_CHAR, this.tabSize) + : lang.stringRepeat(" ", this.tabSize); + + var tabClass = this.showTabs ? " ace_invisible ace_invisible_tab" : ""; + var tabContent = this.showTabs + ? lang.stringRepeat(this.TAB_CHAR, this.tabSize) + : spaceContent; + + var span = this.dom.createElement("span"); + span.className = className + spaceClass; + span.textContent = spaceContent; + this.$tabStrings[" "] = span; + + var span = this.dom.createElement("span"); + span.className = className + tabClass; + span.textContent = tabContent; + this.$tabStrings["\t"] = span; + } + }; + + this.updateLines = function(config, firstRow, lastRow) { + if (this.config.lastRow != config.lastRow || + this.config.firstRow != config.firstRow) { + return this.update(config); + } + + this.config = config; + + var first = Math.max(firstRow, config.firstRow); + var last = Math.min(lastRow, config.lastRow); + + var lineElements = this.element.childNodes; + var lineElementsIdx = 0; + + for (var row = config.firstRow; row < first; row++) { + var foldLine = this.session.getFoldLine(row); + if (foldLine) { + if (foldLine.containsRow(first)) { + first = foldLine.start.row; + break; + } else { + row = foldLine.end.row; + } + } + lineElementsIdx ++; + } + + var heightChanged = false; + var row = first; + var foldLine = this.session.getNextFoldLine(row); + var foldStart = foldLine ? foldLine.start.row : Infinity; + + while (true) { + if (row > foldStart) { + row = foldLine.end.row+1; + foldLine = this.session.getNextFoldLine(row, foldLine); + foldStart = foldLine ? foldLine.start.row :Infinity; + } + if (row > last) + break; + + var lineElement = lineElements[lineElementsIdx++]; + if (lineElement) { + this.dom.removeChildren(lineElement); + this.$renderLine( + lineElement, row, row == foldStart ? foldLine : false + ); + + if (heightChanged) + lineElement.style.top = this.$lines.computeLineTop(row, config, this.session) + "px"; + + var height = (config.lineHeight * this.session.getRowLength(row)) + "px"; + if (lineElement.style.height != height) { + heightChanged = true; + lineElement.style.height = height; + } + } + row++; + } + if (heightChanged) { + while (lineElementsIdx < this.$lines.cells.length) { + var cell = this.$lines.cells[lineElementsIdx++]; + cell.element.style.top = this.$lines.computeLineTop(cell.row, config, this.session) + "px"; + } + } + }; + + this.scrollLines = function(config) { + var oldConfig = this.config; + this.config = config; + + if (this.$lines.pageChanged(oldConfig, config)) + return this.update(config); + + this.$lines.moveContainer(config); + + var lastRow = config.lastRow; + var oldLastRow = oldConfig ? oldConfig.lastRow : -1; + + if (!oldConfig || oldLastRow < config.firstRow) + return this.update(config); + + if (lastRow < oldConfig.firstRow) + return this.update(config); + + if (!oldConfig || oldConfig.lastRow < config.firstRow) + return this.update(config); + + if (config.lastRow < oldConfig.firstRow) + return this.update(config); + + if (oldConfig.firstRow < config.firstRow) + for (var row=this.session.getFoldedRowCount(oldConfig.firstRow, config.firstRow - 1); row>0; row--) + this.$lines.shift(); + + if (oldConfig.lastRow > config.lastRow) + for (var row=this.session.getFoldedRowCount(config.lastRow + 1, oldConfig.lastRow); row>0; row--) + this.$lines.pop(); + + if (config.firstRow < oldConfig.firstRow) { + this.$lines.unshift(this.$renderLinesFragment(config, config.firstRow, oldConfig.firstRow - 1)); + } + + if (config.lastRow > oldConfig.lastRow) { + this.$lines.push(this.$renderLinesFragment(config, oldConfig.lastRow + 1, config.lastRow)); + } + }; + + this.$renderLinesFragment = function(config, firstRow, lastRow) { + var fragment = []; + var row = firstRow; + var foldLine = this.session.getNextFoldLine(row); + var foldStart = foldLine ? foldLine.start.row : Infinity; + + while (true) { + if (row > foldStart) { + row = foldLine.end.row+1; + foldLine = this.session.getNextFoldLine(row, foldLine); + foldStart = foldLine ? foldLine.start.row : Infinity; + } + if (row > lastRow) + break; + + var line = this.$lines.createCell(row, config, this.session); + + var lineEl = line.element; + this.dom.removeChildren(lineEl); + dom.setStyle(lineEl.style, "height", this.$lines.computeLineHeight(row, config, this.session) + "px"); + dom.setStyle(lineEl.style, "top", this.$lines.computeLineTop(row, config, this.session) + "px"); + this.$renderLine(lineEl, row, row == foldStart ? foldLine : false); + + if (this.$useLineGroups()) { + lineEl.className = "ace_line_group"; + } else { + lineEl.className = "ace_line"; + } + fragment.push(line); + + row++; + } + return fragment; + }; + + this.update = function(config) { + this.$lines.moveContainer(config); + + this.config = config; + + var firstRow = config.firstRow; + var lastRow = config.lastRow; + + var lines = this.$lines; + while (lines.getLength()) + lines.pop(); + + lines.push(this.$renderLinesFragment(config, firstRow, lastRow)); + }; + + this.$textToken = { + "text": true, + "rparen": true, + "lparen": true + }; + + this.$renderToken = function(parent, screenColumn, token, value) { + var self = this; + var re = /(\t)|( +)|([\x00-\x1f\x80-\xa0\xad\u1680\u180E\u2000-\u200f\u2028\u2029\u202F\u205F\uFEFF\uFFF9-\uFFFC]+)|(\u3000)|([\u1100-\u115F\u11A3-\u11A7\u11FA-\u11FF\u2329-\u232A\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3001-\u303E\u3041-\u3096\u3099-\u30FF\u3105-\u312D\u3131-\u318E\u3190-\u31BA\u31C0-\u31E3\u31F0-\u321E\u3220-\u3247\u3250-\u32FE\u3300-\u4DBF\u4E00-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFF01-\uFF60\uFFE0-\uFFE6]|[\uD800-\uDBFF][\uDC00-\uDFFF])/g; + + var valueFragment = this.dom.createFragment(this.element); + + var m; + var i = 0; + while (m = re.exec(value)) { + var tab = m[1]; + var simpleSpace = m[2]; + var controlCharacter = m[3]; + var cjkSpace = m[4]; + var cjk = m[5]; + + if (!self.showSpaces && simpleSpace) + continue; + + var before = i != m.index ? value.slice(i, m.index) : ""; + + i = m.index + m[0].length; + + if (before) { + valueFragment.appendChild(this.dom.createTextNode(before, this.element)); + } + + if (tab) { + var tabSize = self.session.getScreenTabSize(screenColumn + m.index); + valueFragment.appendChild(self.$tabStrings[tabSize].cloneNode(true)); + screenColumn += tabSize - 1; + } else if (simpleSpace) { + if (self.showSpaces) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_space"; + span.textContent = lang.stringRepeat(self.SPACE_CHAR, simpleSpace.length); + valueFragment.appendChild(span); + } else { + valueFragment.appendChild(this.com.createTextNode(simpleSpace, this.element)); + } + } else if (controlCharacter) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_space ace_invalid"; + span.textContent = lang.stringRepeat(self.SPACE_CHAR, controlCharacter.length); + valueFragment.appendChild(span); + } else if (cjkSpace) { + screenColumn += 1; + + var span = this.dom.createElement("span"); + span.style.width = (self.config.characterWidth * 2) + "px"; + span.className = self.showSpaces ? "ace_cjk ace_invisible ace_invisible_space" : "ace_cjk"; + span.textContent = self.showSpaces ? self.SPACE_CHAR : cjkSpace; + valueFragment.appendChild(span); + } else if (cjk) { + screenColumn += 1; + var span = this.dom.createElement("span"); + span.style.width = (self.config.characterWidth * 2) + "px"; + span.className = "ace_cjk"; + span.textContent = cjk; + valueFragment.appendChild(span); + } + } + + valueFragment.appendChild(this.dom.createTextNode(i ? value.slice(i) : value, this.element)); + + if (!this.$textToken[token.type]) { + var classes = "ace_" + token.type.replace(/\./g, " ace_"); + var span = this.dom.createElement("span"); + if (token.type == "fold") + span.style.width = (token.value.length * this.config.characterWidth) + "px"; + + span.className = classes; + span.appendChild(valueFragment); + + parent.appendChild(span); + } + else { + parent.appendChild(valueFragment); + } + + return screenColumn + value.length; + }; + + this.renderIndentGuide = function(parent, value, max) { + var cols = value.search(this.$indentGuideRe); + if (cols <= 0 || cols >= max) + return value; + if (value[0] == " ") { + cols -= cols % this.tabSize; + var count = cols/this.tabSize; + for (var i=0; i= splitChars) { + screenColumn = this.$renderToken( + lineEl, screenColumn, + token, value.substring(0, splitChars - chars) + ); + value = value.substring(splitChars - chars); + chars = splitChars; + + lineEl = this.$createLineElement(); + parent.appendChild(lineEl); + + lineEl.appendChild(this.dom.createTextNode(lang.stringRepeat("\xa0", splits.indent), this.element)); + + split ++; + screenColumn = 0; + splitChars = splits[split] || Number.MAX_VALUE; + } + if (value.length != 0) { + chars += value.length; + screenColumn = this.$renderToken( + lineEl, screenColumn, token, value + ); + } + } + } + + if (splits[splits.length - 1] > this.MAX_LINE_LENGTH) + this.$renderOverflowMessage(lineEl, screenColumn, null, "", true); + }; + + this.$renderSimpleLine = function(parent, tokens) { + var screenColumn = 0; + var token = tokens[0]; + var value = token.value; + if (this.displayIndentGuides) + value = this.renderIndentGuide(parent, value); + if (value) + screenColumn = this.$renderToken(parent, screenColumn, token, value); + for (var i = 1; i < tokens.length; i++) { + token = tokens[i]; + value = token.value; + if (screenColumn + value.length > this.MAX_LINE_LENGTH) + return this.$renderOverflowMessage(parent, screenColumn, token, value); + screenColumn = this.$renderToken(parent, screenColumn, token, value); + } + }; + + this.$renderOverflowMessage = function(parent, screenColumn, token, value, hide) { + token && this.$renderToken(parent, screenColumn, token, + value.slice(0, this.MAX_LINE_LENGTH - screenColumn)); + + var overflowEl = this.dom.createElement("span"); + overflowEl.className = "ace_inline_button ace_keyword ace_toggle_wrap"; + overflowEl.textContent = hide ? "" : ""; + + parent.appendChild(overflowEl); + }; + this.$renderLine = function(parent, row, foldLine) { + if (!foldLine && foldLine != false) + foldLine = this.session.getFoldLine(row); + + if (foldLine) + var tokens = this.$getFoldLineTokens(row, foldLine); + else + var tokens = this.session.getTokens(row); + + var lastLineEl = parent; + if (tokens.length) { + var splits = this.session.getRowSplitData(row); + if (splits && splits.length) { + this.$renderWrappedLine(parent, tokens, splits); + var lastLineEl = parent.lastChild; + } else { + var lastLineEl = parent; + if (this.$useLineGroups()) { + lastLineEl = this.$createLineElement(); + parent.appendChild(lastLineEl); + } + this.$renderSimpleLine(lastLineEl, tokens); + } + } else if (this.$useLineGroups()) { + lastLineEl = this.$createLineElement(); + parent.appendChild(lastLineEl); + } + + if (this.showEOL && lastLineEl) { + if (foldLine) + row = foldLine.end.row; + + var invisibleEl = this.dom.createElement("span"); + invisibleEl.className = "ace_invisible ace_invisible_eol"; + invisibleEl.textContent = row == this.session.getLength() - 1 ? this.EOF_CHAR : this.EOL_CHAR; + + lastLineEl.appendChild(invisibleEl); + } + }; + + this.$getFoldLineTokens = function(row, foldLine) { + var session = this.session; + var renderTokens = []; + + function addTokens(tokens, from, to) { + var idx = 0, col = 0; + while ((col + tokens[idx].value.length) < from) { + col += tokens[idx].value.length; + idx++; + + if (idx == tokens.length) + return; + } + if (col != from) { + var value = tokens[idx].value.substring(from - col); + if (value.length > (to - from)) + value = value.substring(0, to - from); + + renderTokens.push({ + type: tokens[idx].type, + value: value + }); + + col = from + value.length; + idx += 1; + } + + while (col < to && idx < tokens.length) { + var value = tokens[idx].value; + if (value.length + col > to) { + renderTokens.push({ + type: tokens[idx].type, + value: value.substring(0, to - col) + }); + } else + renderTokens.push(tokens[idx]); + col += value.length; + idx += 1; + } + } + + var tokens = session.getTokens(row); + foldLine.walk(function(placeholder, row, column, lastColumn, isNewRow) { + if (placeholder != null) { + renderTokens.push({ + type: "fold", + value: placeholder + }); + } else { + if (isNewRow) + tokens = session.getTokens(row); + + if (tokens.length) + addTokens(tokens, lastColumn, column); + } + }, foldLine.end.row, this.session.getLine(foldLine.end.row).length); + + return renderTokens; + }; + + this.$useLineGroups = function() { + return this.session.getUseWrapMode(); + }; + + this.destroy = function() {}; +}).call(Text.prototype); + +exports.Text = Text; + +}); + +ace.define("ace/layer/cursor",["require","exports","module","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var dom = require("../lib/dom"); + +var Cursor = function(parentEl) { + this.element = dom.createElement("div"); + this.element.className = "ace_layer ace_cursor-layer"; + parentEl.appendChild(this.element); + + this.isVisible = false; + this.isBlinking = true; + this.blinkInterval = 1000; + this.smoothBlinking = false; + + this.cursors = []; + this.cursor = this.addCursor(); + dom.addCssClass(this.element, "ace_hidden-cursors"); + this.$updateCursors = this.$updateOpacity.bind(this); +}; + +(function() { + + this.$updateOpacity = function(val) { + var cursors = this.cursors; + for (var i = cursors.length; i--; ) + dom.setStyle(cursors[i].style, "opacity", val ? "" : "0"); + }; + + this.$startCssAnimation = function() { + var cursors = this.cursors; + for (var i = cursors.length; i--; ) + cursors[i].style.animationDuration = this.blinkInterval + "ms"; + + this.$isAnimating = true; + setTimeout(function() { + if (this.$isAnimating) { + dom.addCssClass(this.element, "ace_animate-blinking"); + } + }.bind(this)); + }; + + this.$stopCssAnimation = function() { + this.$isAnimating = false; + dom.removeCssClass(this.element, "ace_animate-blinking"); + }; + + this.$padding = 0; + this.setPadding = function(padding) { + this.$padding = padding; + }; + + this.setSession = function(session) { + this.session = session; + }; + + this.setBlinking = function(blinking) { + if (blinking != this.isBlinking) { + this.isBlinking = blinking; + this.restartTimer(); + } + }; + + this.setBlinkInterval = function(blinkInterval) { + if (blinkInterval != this.blinkInterval) { + this.blinkInterval = blinkInterval; + this.restartTimer(); + } + }; + + this.setSmoothBlinking = function(smoothBlinking) { + if (smoothBlinking != this.smoothBlinking) { + this.smoothBlinking = smoothBlinking; + dom.setCssClass(this.element, "ace_smooth-blinking", smoothBlinking); + this.$updateCursors(true); + this.restartTimer(); + } + }; + + this.addCursor = function() { + var el = dom.createElement("div"); + el.className = "ace_cursor"; + this.element.appendChild(el); + this.cursors.push(el); + return el; + }; + + this.removeCursor = function() { + if (this.cursors.length > 1) { + var el = this.cursors.pop(); + el.parentNode.removeChild(el); + return el; + } + }; + + this.hideCursor = function() { + this.isVisible = false; + dom.addCssClass(this.element, "ace_hidden-cursors"); + this.restartTimer(); + }; + + this.showCursor = function() { + this.isVisible = true; + dom.removeCssClass(this.element, "ace_hidden-cursors"); + this.restartTimer(); + }; + + this.restartTimer = function() { + var update = this.$updateCursors; + clearInterval(this.intervalId); + clearTimeout(this.timeoutId); + this.$stopCssAnimation(); + + if (this.smoothBlinking) { + this.$isSmoothBlinking = false; + dom.removeCssClass(this.element, "ace_smooth-blinking"); + } + + update(true); + + if (!this.isBlinking || !this.blinkInterval || !this.isVisible) { + this.$stopCssAnimation(); + return; + } + + if (this.smoothBlinking) { + this.$isSmoothBlinking = true; + setTimeout(function() { + if (this.$isSmoothBlinking) { + dom.addCssClass(this.element, "ace_smooth-blinking"); + } + }.bind(this)); + } + + if (dom.HAS_CSS_ANIMATION) { + this.$startCssAnimation(); + } else { + var blink = function(){ + this.timeoutId = setTimeout(function() { + update(false); + }, 0.6 * this.blinkInterval); + }.bind(this); + + this.intervalId = setInterval(function() { + update(true); + blink(); + }, this.blinkInterval); + blink(); + } + }; + + this.getPixelPosition = function(position, onScreen) { + if (!this.config || !this.session) + return {left : 0, top : 0}; + + if (!position) + position = this.session.selection.getCursor(); + var pos = this.session.documentToScreenPosition(position); + var cursorLeft = this.$padding + (this.session.$bidiHandler.isBidiRow(pos.row, position.row) + ? this.session.$bidiHandler.getPosLeft(pos.column) + : pos.column * this.config.characterWidth); + + var cursorTop = (pos.row - (onScreen ? this.config.firstRowScreen : 0)) * + this.config.lineHeight; + + return {left : cursorLeft, top : cursorTop}; + }; + + this.isCursorInView = function(pixelPos, config) { + return pixelPos.top >= 0 && pixelPos.top < config.maxHeight; + }; + + this.update = function(config) { + this.config = config; + + var selections = this.session.$selectionMarkers; + var i = 0, cursorIndex = 0; + + if (selections === undefined || selections.length === 0){ + selections = [{cursor: null}]; + } + + for (var i = 0, n = selections.length; i < n; i++) { + var pixelPos = this.getPixelPosition(selections[i].cursor, true); + if ((pixelPos.top > config.height + config.offset || + pixelPos.top < 0) && i > 1) { + continue; + } + + var element = this.cursors[cursorIndex++] || this.addCursor(); + var style = element.style; + + if (!this.drawCursor) { + if (!this.isCursorInView(pixelPos, config)) { + dom.setStyle(style, "display", "none"); + } else { + dom.setStyle(style, "display", "block"); + dom.translate(element, pixelPos.left, pixelPos.top); + dom.setStyle(style, "width", Math.round(config.characterWidth) + "px"); + dom.setStyle(style, "height", config.lineHeight + "px"); + } + } else { + this.drawCursor(element, pixelPos, config, selections[i], this.session); + } + } + while (this.cursors.length > cursorIndex) + this.removeCursor(); + + var overwrite = this.session.getOverwrite(); + this.$setOverwrite(overwrite); + this.$pixelPos = pixelPos; + this.restartTimer(); + }; + + this.drawCursor = null; + + this.$setOverwrite = function(overwrite) { + if (overwrite != this.overwrite) { + this.overwrite = overwrite; + if (overwrite) + dom.addCssClass(this.element, "ace_overwrite-cursors"); + else + dom.removeCssClass(this.element, "ace_overwrite-cursors"); + } + }; + + this.destroy = function() { + clearInterval(this.intervalId); + clearTimeout(this.timeoutId); + }; + +}).call(Cursor.prototype); + +exports.Cursor = Cursor; + +}); + +ace.define("ace/scrollbar",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/event","ace/lib/event_emitter"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var dom = require("./lib/dom"); +var event = require("./lib/event"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var MAX_SCROLL_H = 0x8000; +var ScrollBar = function(parent) { + this.element = dom.createElement("div"); + this.element.className = "ace_scrollbar ace_scrollbar" + this.classSuffix; + + this.inner = dom.createElement("div"); + this.inner.className = "ace_scrollbar-inner"; + this.inner.textContent = "\xa0"; + this.element.appendChild(this.inner); + + parent.appendChild(this.element); + + this.setVisible(false); + this.skipEvent = false; + + event.addListener(this.element, "scroll", this.onScroll.bind(this)); + event.addListener(this.element, "mousedown", event.preventDefault); +}; + +(function() { + oop.implement(this, EventEmitter); + + this.setVisible = function(isVisible) { + this.element.style.display = isVisible ? "" : "none"; + this.isVisible = isVisible; + this.coeff = 1; + }; +}).call(ScrollBar.prototype); +var VScrollBar = function(parent, renderer) { + ScrollBar.call(this, parent); + this.scrollTop = 0; + this.scrollHeight = 0; + renderer.$scrollbarWidth = + this.width = dom.scrollbarWidth(parent.ownerDocument); + this.inner.style.width = + this.element.style.width = (this.width || 15) + 5 + "px"; + this.$minWidth = 0; +}; + +oop.inherits(VScrollBar, ScrollBar); + +(function() { + + this.classSuffix = '-v'; + this.onScroll = function() { + if (!this.skipEvent) { + this.scrollTop = this.element.scrollTop; + if (this.coeff != 1) { + var h = this.element.clientHeight / this.scrollHeight; + this.scrollTop = this.scrollTop * (1 - h) / (this.coeff - h); + } + this._emit("scroll", {data: this.scrollTop}); + } + this.skipEvent = false; + }; + this.getWidth = function() { + return Math.max(this.isVisible ? this.width : 0, this.$minWidth || 0); + }; + this.setHeight = function(height) { + this.element.style.height = height + "px"; + }; + this.setInnerHeight = + this.setScrollHeight = function(height) { + this.scrollHeight = height; + if (height > MAX_SCROLL_H) { + this.coeff = MAX_SCROLL_H / height; + height = MAX_SCROLL_H; + } else if (this.coeff != 1) { + this.coeff = 1; + } + this.inner.style.height = height + "px"; + }; + this.setScrollTop = function(scrollTop) { + if (this.scrollTop != scrollTop) { + this.skipEvent = true; + this.scrollTop = scrollTop; + this.element.scrollTop = scrollTop * this.coeff; + } + }; + +}).call(VScrollBar.prototype); +var HScrollBar = function(parent, renderer) { + ScrollBar.call(this, parent); + this.scrollLeft = 0; + this.height = renderer.$scrollbarWidth; + this.inner.style.height = + this.element.style.height = (this.height || 15) + 5 + "px"; +}; + +oop.inherits(HScrollBar, ScrollBar); + +(function() { + + this.classSuffix = '-h'; + this.onScroll = function() { + if (!this.skipEvent) { + this.scrollLeft = this.element.scrollLeft; + this._emit("scroll", {data: this.scrollLeft}); + } + this.skipEvent = false; + }; + this.getHeight = function() { + return this.isVisible ? this.height : 0; + }; + this.setWidth = function(width) { + this.element.style.width = width + "px"; + }; + this.setInnerWidth = function(width) { + this.inner.style.width = width + "px"; + }; + this.setScrollWidth = function(width) { + this.inner.style.width = width + "px"; + }; + this.setScrollLeft = function(scrollLeft) { + if (this.scrollLeft != scrollLeft) { + this.skipEvent = true; + this.scrollLeft = this.element.scrollLeft = scrollLeft; + } + }; + +}).call(HScrollBar.prototype); + + +exports.ScrollBar = VScrollBar; // backward compatibility +exports.ScrollBarV = VScrollBar; // backward compatibility +exports.ScrollBarH = HScrollBar; // backward compatibility + +exports.VScrollBar = VScrollBar; +exports.HScrollBar = HScrollBar; +}); + +ace.define("ace/renderloop",["require","exports","module","ace/lib/event"], function(require, exports, module) { +"use strict"; + +var event = require("./lib/event"); + + +var RenderLoop = function(onRender, win) { + this.onRender = onRender; + this.pending = false; + this.changes = 0; + this.$recursionLimit = 2; + this.window = win || window; + var _self = this; + this._flush = function(ts) { + _self.pending = false; + var changes = _self.changes; + + if (changes) { + event.blockIdle(100); + _self.changes = 0; + _self.onRender(changes); + } + + if (_self.changes) { + if (_self.$recursionLimit-- < 0) return; + _self.schedule(); + } else { + _self.$recursionLimit = 2; + } + }; +}; + +(function() { + + this.schedule = function(change) { + this.changes = this.changes | change; + if (this.changes && !this.pending) { + event.nextFrame(this._flush); + this.pending = true; + } + }; + + this.clear = function(change) { + var changes = this.changes; + this.changes = 0; + return changes; + }; + +}).call(RenderLoop.prototype); + +exports.RenderLoop = RenderLoop; +}); + +ace.define("ace/layer/font_metrics",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/lib/lang","ace/lib/event","ace/lib/useragent","ace/lib/event_emitter"], function(require, exports, module) { + +var oop = require("../lib/oop"); +var dom = require("../lib/dom"); +var lang = require("../lib/lang"); +var event = require("../lib/event"); +var useragent = require("../lib/useragent"); +var EventEmitter = require("../lib/event_emitter").EventEmitter; + +var CHAR_COUNT = 256; +var USE_OBSERVER = typeof ResizeObserver == "function"; +var L = 200; + +var FontMetrics = exports.FontMetrics = function(parentEl) { + this.el = dom.createElement("div"); + this.$setMeasureNodeStyles(this.el.style, true); + + this.$main = dom.createElement("div"); + this.$setMeasureNodeStyles(this.$main.style); + + this.$measureNode = dom.createElement("div"); + this.$setMeasureNodeStyles(this.$measureNode.style); + + + this.el.appendChild(this.$main); + this.el.appendChild(this.$measureNode); + parentEl.appendChild(this.el); + + this.$measureNode.textContent = lang.stringRepeat("X", CHAR_COUNT); + + this.$characterSize = {width: 0, height: 0}; + + + if (USE_OBSERVER) + this.$addObserver(); + else + this.checkForSizeChanges(); +}; + +(function() { + + oop.implement(this, EventEmitter); + + this.$characterSize = {width: 0, height: 0}; + + this.$setMeasureNodeStyles = function(style, isRoot) { + style.width = style.height = "auto"; + style.left = style.top = "0px"; + style.visibility = "hidden"; + style.position = "absolute"; + style.whiteSpace = "pre"; + + if (useragent.isIE < 8) { + style["font-family"] = "inherit"; + } else { + style.font = "inherit"; + } + style.overflow = isRoot ? "hidden" : "visible"; + }; + + this.checkForSizeChanges = function(size) { + if (size === undefined) + size = this.$measureSizes(); + if (size && (this.$characterSize.width !== size.width || this.$characterSize.height !== size.height)) { + this.$measureNode.style.fontWeight = "bold"; + var boldSize = this.$measureSizes(); + this.$measureNode.style.fontWeight = ""; + this.$characterSize = size; + this.charSizes = Object.create(null); + this.allowBoldFonts = boldSize && boldSize.width === size.width && boldSize.height === size.height; + this._emit("changeCharacterSize", {data: size}); + } + }; + + this.$addObserver = function() { + var self = this; + this.$observer = new window.ResizeObserver(function(e) { + self.checkForSizeChanges(); + }); + this.$observer.observe(this.$measureNode); + }; + + this.$pollSizeChanges = function() { + if (this.$pollSizeChangesTimer || this.$observer) + return this.$pollSizeChangesTimer; + var self = this; + + return this.$pollSizeChangesTimer = event.onIdle(function cb() { + self.checkForSizeChanges(); + event.onIdle(cb, 500); + }, 500); + }; + + this.setPolling = function(val) { + if (val) { + this.$pollSizeChanges(); + } else if (this.$pollSizeChangesTimer) { + clearInterval(this.$pollSizeChangesTimer); + this.$pollSizeChangesTimer = 0; + } + }; + + this.$measureSizes = function(node) { + var size = { + height: (node || this.$measureNode).clientHeight, + width: (node || this.$measureNode).clientWidth / CHAR_COUNT + }; + if (size.width === 0 || size.height === 0) + return null; + return size; + }; + + this.$measureCharWidth = function(ch) { + this.$main.textContent = lang.stringRepeat(ch, CHAR_COUNT); + var rect = this.$main.getBoundingClientRect(); + return rect.width / CHAR_COUNT; + }; + + this.getCharacterWidth = function(ch) { + var w = this.charSizes[ch]; + if (w === undefined) { + w = this.charSizes[ch] = this.$measureCharWidth(ch) / this.$characterSize.width; + } + return w; + }; + + this.destroy = function() { + clearInterval(this.$pollSizeChangesTimer); + if (this.$observer) + this.$observer.disconnect(); + if (this.el && this.el.parentNode) + this.el.parentNode.removeChild(this.el); + }; + + + this.$getZoom = function getZoom(element) { + if (!element || !element.parentElement) return 1; + return (window.getComputedStyle(element).zoom || 1) * getZoom(element.parentElement); + }; + this.$initTransformMeasureNodes = function() { + var t = function(t, l) { + return ["div", { + style: "position: absolute;top:" + t + "px;left:" + l + "px;" + }]; + }; + this.els = dom.buildDom([t(0, 0), t(L, 0), t(0, L), t(L, L)], this.el); + }; + this.transformCoordinates = function(clientPos, elPos) { + if (clientPos) { + var zoom = this.$getZoom(this.el); + clientPos = mul(1 / zoom, clientPos); + } + function solve(l1, l2, r) { + var det = l1[1] * l2[0] - l1[0] * l2[1]; + return [ + (-l2[1] * r[0] + l2[0] * r[1]) / det, + (+l1[1] * r[0] - l1[0] * r[1]) / det + ]; + } + function sub(a, b) { return [a[0] - b[0], a[1] - b[1]]; } + function add(a, b) { return [a[0] + b[0], a[1] + b[1]]; } + function mul(a, b) { return [a * b[0], a * b[1]]; } + + if (!this.els) + this.$initTransformMeasureNodes(); + + function p(el) { + var r = el.getBoundingClientRect(); + return [r.left, r.top]; + } + + var a = p(this.els[0]); + var b = p(this.els[1]); + var c = p(this.els[2]); + var d = p(this.els[3]); + + var h = solve(sub(d, b), sub(d, c), sub(add(b, c), add(d, a))); + + var m1 = mul(1 + h[0], sub(b, a)); + var m2 = mul(1 + h[1], sub(c, a)); + + if (elPos) { + var x = elPos; + var k = h[0] * x[0] / L + h[1] * x[1] / L + 1; + var ut = add(mul(x[0], m1), mul(x[1], m2)); + return add(mul(1 / k / L, ut), a); + } + var u = sub(clientPos, a); + var f = solve(sub(m1, mul(h[0], u)), sub(m2, mul(h[1], u)), u); + return mul(L, f); + }; + +}).call(FontMetrics.prototype); + +}); + +ace.define("ace/virtual_renderer",["require","exports","module","ace/lib/oop","ace/lib/dom","ace/config","ace/layer/gutter","ace/layer/marker","ace/layer/text","ace/layer/cursor","ace/scrollbar","ace/scrollbar","ace/renderloop","ace/layer/font_metrics","ace/lib/event_emitter","ace/lib/useragent"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var dom = require("./lib/dom"); +var config = require("./config"); +var GutterLayer = require("./layer/gutter").Gutter; +var MarkerLayer = require("./layer/marker").Marker; +var TextLayer = require("./layer/text").Text; +var CursorLayer = require("./layer/cursor").Cursor; +var HScrollBar = require("./scrollbar").HScrollBar; +var VScrollBar = require("./scrollbar").VScrollBar; +var RenderLoop = require("./renderloop").RenderLoop; +var FontMetrics = require("./layer/font_metrics").FontMetrics; +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var editorCss = "\ +.ace_br1 {border-top-left-radius : 3px;}\ +.ace_br2 {border-top-right-radius : 3px;}\ +.ace_br3 {border-top-left-radius : 3px; border-top-right-radius: 3px;}\ +.ace_br4 {border-bottom-right-radius: 3px;}\ +.ace_br5 {border-top-left-radius : 3px; border-bottom-right-radius: 3px;}\ +.ace_br6 {border-top-right-radius : 3px; border-bottom-right-radius: 3px;}\ +.ace_br7 {border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px;}\ +.ace_br8 {border-bottom-left-radius : 3px;}\ +.ace_br9 {border-top-left-radius : 3px; border-bottom-left-radius: 3px;}\ +.ace_br10{border-top-right-radius : 3px; border-bottom-left-radius: 3px;}\ +.ace_br11{border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br12{border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br13{border-top-left-radius : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br14{border-top-right-radius : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br15{border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_editor {\ +position: relative;\ +overflow: hidden;\ +padding: 0;\ +font: 12px/normal 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;\ +direction: ltr;\ +text-align: left;\ +-webkit-tap-highlight-color: rgba(0, 0, 0, 0);\ +}\ +.ace_scroller {\ +position: absolute;\ +overflow: hidden;\ +top: 0;\ +bottom: 0;\ +background-color: inherit;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +cursor: text;\ +}\ +.ace_content {\ +position: absolute;\ +box-sizing: border-box;\ +min-width: 100%;\ +contain: style size layout;\ +font-variant-ligatures: no-common-ligatures;\ +}\ +.ace_dragging .ace_scroller:before{\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +bottom: 0;\ +content: '';\ +background: rgba(250, 250, 250, 0.01);\ +z-index: 1000;\ +}\ +.ace_dragging.ace_dark .ace_scroller:before{\ +background: rgba(0, 0, 0, 0.01);\ +}\ +.ace_selecting, .ace_selecting * {\ +cursor: text !important;\ +}\ +.ace_gutter {\ +position: absolute;\ +overflow : hidden;\ +width: auto;\ +top: 0;\ +bottom: 0;\ +left: 0;\ +cursor: default;\ +z-index: 4;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +contain: style size layout;\ +}\ +.ace_gutter-active-line {\ +position: absolute;\ +left: 0;\ +right: 0;\ +}\ +.ace_scroller.ace_scroll-left {\ +box-shadow: 17px 0 16px -16px rgba(0, 0, 0, 0.4) inset;\ +}\ +.ace_gutter-cell {\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +padding-left: 19px;\ +padding-right: 6px;\ +background-repeat: no-repeat;\ +}\ +.ace_gutter-cell.ace_error {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAABOFBMVEX/////////QRswFAb/Ui4wFAYwFAYwFAaWGAfDRymzOSH/PxswFAb/SiUwFAYwFAbUPRvjQiDllog5HhHdRybsTi3/Tyv9Tir+Syj/UC3////XurebMBIwFAb/RSHbPx/gUzfdwL3kzMivKBAwFAbbvbnhPx66NhowFAYwFAaZJg8wFAaxKBDZurf/RB6mMxb/SCMwFAYwFAbxQB3+RB4wFAb/Qhy4Oh+4QifbNRcwFAYwFAYwFAb/QRzdNhgwFAYwFAbav7v/Uy7oaE68MBK5LxLewr/r2NXewLswFAaxJw4wFAbkPRy2PyYwFAaxKhLm1tMwFAazPiQwFAaUGAb/QBrfOx3bvrv/VC/maE4wFAbRPBq6MRO8Qynew8Dp2tjfwb0wFAbx6eju5+by6uns4uH9/f36+vr/GkHjAAAAYnRSTlMAGt+64rnWu/bo8eAA4InH3+DwoN7j4eLi4xP99Nfg4+b+/u9B/eDs1MD1mO7+4PHg2MXa347g7vDizMLN4eG+Pv7i5evs/v79yu7S3/DV7/498Yv24eH+4ufQ3Ozu/v7+y13sRqwAAADLSURBVHjaZc/XDsFgGIBhtDrshlitmk2IrbHFqL2pvXf/+78DPokj7+Fz9qpU/9UXJIlhmPaTaQ6QPaz0mm+5gwkgovcV6GZzd5JtCQwgsxoHOvJO15kleRLAnMgHFIESUEPmawB9ngmelTtipwwfASilxOLyiV5UVUyVAfbG0cCPHig+GBkzAENHS0AstVF6bacZIOzgLmxsHbt2OecNgJC83JERmePUYq8ARGkJx6XtFsdddBQgZE2nPR6CICZhawjA4Fb/chv+399kfR+MMMDGOQAAAABJRU5ErkJggg==\");\ +background-repeat: no-repeat;\ +background-position: 2px center;\ +}\ +.ace_gutter-cell.ace_warning {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAmVBMVEX///8AAAD///8AAAAAAABPSzb/5sAAAAB/blH/73z/ulkAAAAAAAD85pkAAAAAAAACAgP/vGz/rkDerGbGrV7/pkQICAf////e0IsAAAD/oED/qTvhrnUAAAD/yHD/njcAAADuv2r/nz//oTj/p064oGf/zHAAAAA9Nir/tFIAAAD/tlTiuWf/tkIAAACynXEAAAAAAAAtIRW7zBpBAAAAM3RSTlMAABR1m7RXO8Ln31Z36zT+neXe5OzooRDfn+TZ4p3h2hTf4t3k3ucyrN1K5+Xaks52Sfs9CXgrAAAAjklEQVR42o3PbQ+CIBQFYEwboPhSYgoYunIqqLn6/z8uYdH8Vmdnu9vz4WwXgN/xTPRD2+sgOcZjsge/whXZgUaYYvT8QnuJaUrjrHUQreGczuEafQCO/SJTufTbroWsPgsllVhq3wJEk2jUSzX3CUEDJC84707djRc5MTAQxoLgupWRwW6UB5fS++NV8AbOZgnsC7BpEAAAAABJRU5ErkJggg==\");\ +background-position: 2px center;\ +}\ +.ace_gutter-cell.ace_info {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAJ0Uk5TAAB2k804AAAAPklEQVQY02NgIB68QuO3tiLznjAwpKTgNyDbMegwisCHZUETUZV0ZqOquBpXj2rtnpSJT1AEnnRmL2OgGgAAIKkRQap2htgAAAAASUVORK5CYII=\");\ +background-position: 2px center;\ +}\ +.ace_dark .ace_gutter-cell.ace_info {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAJFBMVEUAAAChoaGAgIAqKiq+vr6tra1ZWVmUlJSbm5s8PDxubm56enrdgzg3AAAAAXRSTlMAQObYZgAAAClJREFUeNpjYMAPdsMYHegyJZFQBlsUlMFVCWUYKkAZMxZAGdxlDMQBAG+TBP4B6RyJAAAAAElFTkSuQmCC\");\ +}\ +.ace_scrollbar {\ +contain: strict;\ +position: absolute;\ +right: 0;\ +bottom: 0;\ +z-index: 6;\ +}\ +.ace_scrollbar-inner {\ +position: absolute;\ +cursor: text;\ +left: 0;\ +top: 0;\ +}\ +.ace_scrollbar-v{\ +overflow-x: hidden;\ +overflow-y: scroll;\ +top: 0;\ +}\ +.ace_scrollbar-h {\ +overflow-x: scroll;\ +overflow-y: hidden;\ +left: 0;\ +}\ +.ace_print-margin {\ +position: absolute;\ +height: 100%;\ +}\ +.ace_text-input {\ +position: absolute;\ +z-index: 0;\ +width: 0.5em;\ +height: 1em;\ +opacity: 0;\ +background: transparent;\ +-moz-appearance: none;\ +appearance: none;\ +border: none;\ +resize: none;\ +outline: none;\ +overflow: hidden;\ +font: inherit;\ +padding: 0 1px;\ +margin: 0 -1px;\ +contain: strict;\ +-ms-user-select: text;\ +-moz-user-select: text;\ +-webkit-user-select: text;\ +user-select: text;\ +white-space: pre!important;\ +}\ +.ace_text-input.ace_composition {\ +background: transparent;\ +color: inherit;\ +z-index: 1000;\ +opacity: 1;\ +}\ +.ace_composition_placeholder { color: transparent }\ +.ace_composition_marker { \ +border-bottom: 1px solid;\ +position: absolute;\ +border-radius: 0;\ +margin-top: 1px;\ +}\ +[ace_nocontext=true] {\ +transform: none!important;\ +filter: none!important;\ +clip-path: none!important;\ +mask : none!important;\ +contain: none!important;\ +perspective: none!important;\ +mix-blend-mode: initial!important;\ +z-index: auto;\ +}\ +.ace_layer {\ +z-index: 1;\ +position: absolute;\ +overflow: hidden;\ +word-wrap: normal;\ +white-space: pre;\ +height: 100%;\ +width: 100%;\ +box-sizing: border-box;\ +pointer-events: none;\ +}\ +.ace_gutter-layer {\ +position: relative;\ +width: auto;\ +text-align: right;\ +pointer-events: auto;\ +height: 1000000px;\ +contain: style size layout;\ +}\ +.ace_text-layer {\ +font: inherit !important;\ +position: absolute;\ +height: 1000000px;\ +width: 1000000px;\ +contain: style size layout;\ +}\ +.ace_text-layer > .ace_line, .ace_text-layer > .ace_line_group {\ +contain: style size layout;\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +}\ +.ace_hidpi .ace_text-layer,\ +.ace_hidpi .ace_gutter-layer,\ +.ace_hidpi .ace_content,\ +.ace_hidpi .ace_gutter {\ +contain: strict;\ +will-change: transform;\ +}\ +.ace_hidpi .ace_text-layer > .ace_line, \ +.ace_hidpi .ace_text-layer > .ace_line_group {\ +contain: strict;\ +}\ +.ace_cjk {\ +display: inline-block;\ +text-align: center;\ +}\ +.ace_cursor-layer {\ +z-index: 4;\ +}\ +.ace_cursor {\ +z-index: 4;\ +position: absolute;\ +box-sizing: border-box;\ +border-left: 2px solid;\ +transform: translatez(0);\ +}\ +.ace_multiselect .ace_cursor {\ +border-left-width: 1px;\ +}\ +.ace_slim-cursors .ace_cursor {\ +border-left-width: 1px;\ +}\ +.ace_overwrite-cursors .ace_cursor {\ +border-left-width: 0;\ +border-bottom: 1px solid;\ +}\ +.ace_hidden-cursors .ace_cursor {\ +opacity: 0.2;\ +}\ +.ace_hasPlaceholder .ace_hidden-cursors .ace_cursor {\ +opacity: 0;\ +}\ +.ace_smooth-blinking .ace_cursor {\ +transition: opacity 0.18s;\ +}\ +.ace_animate-blinking .ace_cursor {\ +animation-duration: 1000ms;\ +animation-timing-function: step-end;\ +animation-name: blink-ace-animate;\ +animation-iteration-count: infinite;\ +}\ +.ace_animate-blinking.ace_smooth-blinking .ace_cursor {\ +animation-duration: 1000ms;\ +animation-timing-function: ease-in-out;\ +animation-name: blink-ace-animate-smooth;\ +}\ +@keyframes blink-ace-animate {\ +from, to { opacity: 1; }\ +60% { opacity: 0; }\ +}\ +@keyframes blink-ace-animate-smooth {\ +from, to { opacity: 1; }\ +45% { opacity: 1; }\ +60% { opacity: 0; }\ +85% { opacity: 0; }\ +}\ +.ace_marker-layer .ace_step, .ace_marker-layer .ace_stack {\ +position: absolute;\ +z-index: 3;\ +}\ +.ace_marker-layer .ace_selection {\ +position: absolute;\ +z-index: 5;\ +}\ +.ace_marker-layer .ace_bracket {\ +position: absolute;\ +z-index: 6;\ +}\ +.ace_marker-layer .ace_error_bracket {\ +position: absolute;\ +border-bottom: 1px solid #DE5555;\ +border-radius: 0;\ +}\ +.ace_marker-layer .ace_active-line {\ +position: absolute;\ +z-index: 2;\ +}\ +.ace_marker-layer .ace_selected-word {\ +position: absolute;\ +z-index: 4;\ +box-sizing: border-box;\ +}\ +.ace_line .ace_fold {\ +box-sizing: border-box;\ +display: inline-block;\ +height: 11px;\ +margin-top: -2px;\ +vertical-align: middle;\ +background-image:\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII=\"),\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACJJREFUeNpi+P//fxgTAwPDBxDxD078RSX+YeEyDFMCIMAAI3INmXiwf2YAAAAASUVORK5CYII=\");\ +background-repeat: no-repeat, repeat-x;\ +background-position: center center, top left;\ +color: transparent;\ +border: 1px solid black;\ +border-radius: 2px;\ +cursor: pointer;\ +pointer-events: auto;\ +}\ +.ace_dark .ace_fold {\ +}\ +.ace_fold:hover{\ +background-image:\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII=\"),\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACBJREFUeNpi+P//fz4TAwPDZxDxD5X4i5fLMEwJgAADAEPVDbjNw87ZAAAAAElFTkSuQmCC\");\ +}\ +.ace_tooltip {\ +background-color: #FFF;\ +background-image: linear-gradient(to bottom, transparent, rgba(0, 0, 0, 0.1));\ +border: 1px solid gray;\ +border-radius: 1px;\ +box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);\ +color: black;\ +max-width: 100%;\ +padding: 3px 4px;\ +position: fixed;\ +z-index: 999999;\ +box-sizing: border-box;\ +cursor: default;\ +white-space: pre;\ +word-wrap: break-word;\ +line-height: normal;\ +font-style: normal;\ +font-weight: normal;\ +letter-spacing: normal;\ +pointer-events: none;\ +}\ +.ace_folding-enabled > .ace_gutter-cell {\ +padding-right: 13px;\ +}\ +.ace_fold-widget {\ +box-sizing: border-box;\ +margin: 0 -12px 0 1px;\ +display: none;\ +width: 11px;\ +vertical-align: top;\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42mWKsQ0AMAzC8ixLlrzQjzmBiEjp0A6WwBCSPgKAXoLkqSot7nN3yMwR7pZ32NzpKkVoDBUxKAAAAABJRU5ErkJggg==\");\ +background-repeat: no-repeat;\ +background-position: center;\ +border-radius: 3px;\ +border: 1px solid transparent;\ +cursor: pointer;\ +}\ +.ace_folding-enabled .ace_fold-widget {\ +display: inline-block; \ +}\ +.ace_fold-widget.ace_end {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42m3HwQkAMAhD0YzsRchFKI7sAikeWkrxwScEB0nh5e7KTPWimZki4tYfVbX+MNl4pyZXejUO1QAAAABJRU5ErkJggg==\");\ +}\ +.ace_fold-widget.ace_closed {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAGCAYAAAAG5SQMAAAAOUlEQVR42jXKwQkAMAgDwKwqKD4EwQ26sSOkVWjgIIHAzPiCgaqiqnJHZnKICBERHN194O5b9vbLuAVRL+l0YWnZAAAAAElFTkSuQmCCXA==\");\ +}\ +.ace_fold-widget:hover {\ +border: 1px solid rgba(0, 0, 0, 0.3);\ +background-color: rgba(255, 255, 255, 0.2);\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.7);\ +}\ +.ace_fold-widget:active {\ +border: 1px solid rgba(0, 0, 0, 0.4);\ +background-color: rgba(0, 0, 0, 0.05);\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.8);\ +}\ +.ace_dark .ace_fold-widget {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHklEQVQIW2P4//8/AzoGEQ7oGCaLLAhWiSwB146BAQCSTPYocqT0AAAAAElFTkSuQmCC\");\ +}\ +.ace_dark .ace_fold-widget.ace_end {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAH0lEQVQIW2P4//8/AxQ7wNjIAjDMgC4AxjCVKBirIAAF0kz2rlhxpAAAAABJRU5ErkJggg==\");\ +}\ +.ace_dark .ace_fold-widget.ace_closed {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAFCAYAAACAcVaiAAAAHElEQVQIW2P4//+/AxAzgDADlOOAznHAKgPWAwARji8UIDTfQQAAAABJRU5ErkJggg==\");\ +}\ +.ace_dark .ace_fold-widget:hover {\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);\ +background-color: rgba(255, 255, 255, 0.1);\ +}\ +.ace_dark .ace_fold-widget:active {\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);\ +}\ +.ace_inline_button {\ +border: 1px solid lightgray;\ +display: inline-block;\ +margin: -1px 8px;\ +padding: 0 5px;\ +pointer-events: auto;\ +cursor: pointer;\ +}\ +.ace_inline_button:hover {\ +border-color: gray;\ +background: rgba(200,200,200,0.2);\ +display: inline-block;\ +pointer-events: auto;\ +}\ +.ace_fold-widget.ace_invalid {\ +background-color: #FFB4B4;\ +border-color: #DE5555;\ +}\ +.ace_fade-fold-widgets .ace_fold-widget {\ +transition: opacity 0.4s ease 0.05s;\ +opacity: 0;\ +}\ +.ace_fade-fold-widgets:hover .ace_fold-widget {\ +transition: opacity 0.05s ease 0.05s;\ +opacity:1;\ +}\ +.ace_underline {\ +text-decoration: underline;\ +}\ +.ace_bold {\ +font-weight: bold;\ +}\ +.ace_nobold .ace_bold {\ +font-weight: normal;\ +}\ +.ace_italic {\ +font-style: italic;\ +}\ +.ace_error-marker {\ +background-color: rgba(255, 0, 0,0.2);\ +position: absolute;\ +z-index: 9;\ +}\ +.ace_highlight-marker {\ +background-color: rgba(255, 255, 0,0.2);\ +position: absolute;\ +z-index: 8;\ +}\ +.ace_mobile-menu {\ +position: absolute;\ +line-height: 1.5;\ +border-radius: 4px;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +background: white;\ +box-shadow: 1px 3px 2px grey;\ +border: 1px solid #dcdcdc;\ +color: black;\ +}\ +.ace_dark > .ace_mobile-menu {\ +background: #333;\ +color: #ccc;\ +box-shadow: 1px 3px 2px grey;\ +border: 1px solid #444;\ +}\ +.ace_mobile-button {\ +padding: 2px;\ +cursor: pointer;\ +overflow: hidden;\ +}\ +.ace_mobile-button:hover {\ +background-color: #eee;\ +opacity:1;\ +}\ +.ace_mobile-button:active {\ +background-color: #ddd;\ +}\ +.ace_placeholder {\ +font-family: arial;\ +transform: scale(0.9);\ +transform-origin: left;\ +white-space: pre;\ +opacity: 0.7;\ +margin: 0 10px;\ +}"; + +var useragent = require("./lib/useragent"); +var HIDE_TEXTAREA = useragent.isIE; + +dom.importCssString(editorCss, "ace_editor.css", false); + +var VirtualRenderer = function(container, theme) { + var _self = this; + + this.container = container || dom.createElement("div"); + + dom.addCssClass(this.container, "ace_editor"); + if (dom.HI_DPI) dom.addCssClass(this.container, "ace_hidpi"); + + this.setTheme(theme); + if (config.get("useStrictCSP") == null) + config.set("useStrictCSP", false); + + this.$gutter = dom.createElement("div"); + this.$gutter.className = "ace_gutter"; + this.container.appendChild(this.$gutter); + this.$gutter.setAttribute("aria-hidden", true); + + this.scroller = dom.createElement("div"); + this.scroller.className = "ace_scroller"; + + this.container.appendChild(this.scroller); + + this.content = dom.createElement("div"); + this.content.className = "ace_content"; + this.scroller.appendChild(this.content); + + this.$gutterLayer = new GutterLayer(this.$gutter); + this.$gutterLayer.on("changeGutterWidth", this.onGutterResize.bind(this)); + + this.$markerBack = new MarkerLayer(this.content); + + var textLayer = this.$textLayer = new TextLayer(this.content); + this.canvas = textLayer.element; + + this.$markerFront = new MarkerLayer(this.content); + + this.$cursorLayer = new CursorLayer(this.content); + this.$horizScroll = false; + this.$vScroll = false; + + this.scrollBar = + this.scrollBarV = new VScrollBar(this.container, this); + this.scrollBarH = new HScrollBar(this.container, this); + this.scrollBarV.on("scroll", function(e) { + if (!_self.$scrollAnimation) + _self.session.setScrollTop(e.data - _self.scrollMargin.top); + }); + this.scrollBarH.on("scroll", function(e) { + if (!_self.$scrollAnimation) + _self.session.setScrollLeft(e.data - _self.scrollMargin.left); + }); + + this.scrollTop = 0; + this.scrollLeft = 0; + + this.cursorPos = { + row : 0, + column : 0 + }; + + this.$fontMetrics = new FontMetrics(this.container); + this.$textLayer.$setFontMetrics(this.$fontMetrics); + this.$textLayer.on("changeCharacterSize", function(e) { + _self.updateCharacterSize(); + _self.onResize(true, _self.gutterWidth, _self.$size.width, _self.$size.height); + _self._signal("changeCharacterSize", e); + }); + + this.$size = { + width: 0, + height: 0, + scrollerHeight: 0, + scrollerWidth: 0, + $dirty: true + }; + + this.layerConfig = { + width : 1, + padding : 0, + firstRow : 0, + firstRowScreen: 0, + lastRow : 0, + lineHeight : 0, + characterWidth : 0, + minHeight : 1, + maxHeight : 1, + offset : 0, + height : 1, + gutterOffset: 1 + }; + + this.scrollMargin = { + left: 0, + right: 0, + top: 0, + bottom: 0, + v: 0, + h: 0 + }; + + this.margin = { + left: 0, + right: 0, + top: 0, + bottom: 0, + v: 0, + h: 0 + }; + + this.$keepTextAreaAtCursor = !useragent.isIOS; + + this.$loop = new RenderLoop( + this.$renderChanges.bind(this), + this.container.ownerDocument.defaultView + ); + this.$loop.schedule(this.CHANGE_FULL); + + this.updateCharacterSize(); + this.setPadding(4); + config.resetOptions(this); + config._signal("renderer", this); +}; + +(function() { + + this.CHANGE_CURSOR = 1; + this.CHANGE_MARKER = 2; + this.CHANGE_GUTTER = 4; + this.CHANGE_SCROLL = 8; + this.CHANGE_LINES = 16; + this.CHANGE_TEXT = 32; + this.CHANGE_SIZE = 64; + this.CHANGE_MARKER_BACK = 128; + this.CHANGE_MARKER_FRONT = 256; + this.CHANGE_FULL = 512; + this.CHANGE_H_SCROLL = 1024; + + oop.implement(this, EventEmitter); + + this.updateCharacterSize = function() { + if (this.$textLayer.allowBoldFonts != this.$allowBoldFonts) { + this.$allowBoldFonts = this.$textLayer.allowBoldFonts; + this.setStyle("ace_nobold", !this.$allowBoldFonts); + } + + this.layerConfig.characterWidth = + this.characterWidth = this.$textLayer.getCharacterWidth(); + this.layerConfig.lineHeight = + this.lineHeight = this.$textLayer.getLineHeight(); + this.$updatePrintMargin(); + dom.setStyle(this.scroller.style, "line-height", this.lineHeight + "px"); + }; + this.setSession = function(session) { + if (this.session) + this.session.doc.off("changeNewLineMode", this.onChangeNewLineMode); + + this.session = session; + if (session && this.scrollMargin.top && session.getScrollTop() <= 0) + session.setScrollTop(-this.scrollMargin.top); + + this.$cursorLayer.setSession(session); + this.$markerBack.setSession(session); + this.$markerFront.setSession(session); + this.$gutterLayer.setSession(session); + this.$textLayer.setSession(session); + if (!session) + return; + + this.$loop.schedule(this.CHANGE_FULL); + this.session.$setFontMetrics(this.$fontMetrics); + this.scrollBarH.scrollLeft = this.scrollBarV.scrollTop = null; + + this.onChangeNewLineMode = this.onChangeNewLineMode.bind(this); + this.onChangeNewLineMode(); + this.session.doc.on("changeNewLineMode", this.onChangeNewLineMode); + }; + this.updateLines = function(firstRow, lastRow, force) { + if (lastRow === undefined) + lastRow = Infinity; + + if (!this.$changedLines) { + this.$changedLines = { + firstRow: firstRow, + lastRow: lastRow + }; + } + else { + if (this.$changedLines.firstRow > firstRow) + this.$changedLines.firstRow = firstRow; + + if (this.$changedLines.lastRow < lastRow) + this.$changedLines.lastRow = lastRow; + } + if (this.$changedLines.lastRow < this.layerConfig.firstRow) { + if (force) + this.$changedLines.lastRow = this.layerConfig.lastRow; + else + return; + } + if (this.$changedLines.firstRow > this.layerConfig.lastRow) + return; + this.$loop.schedule(this.CHANGE_LINES); + }; + + this.onChangeNewLineMode = function() { + this.$loop.schedule(this.CHANGE_TEXT); + this.$textLayer.$updateEolChar(); + this.session.$bidiHandler.setEolChar(this.$textLayer.EOL_CHAR); + }; + + this.onChangeTabSize = function() { + this.$loop.schedule(this.CHANGE_TEXT | this.CHANGE_MARKER); + this.$textLayer.onChangeTabSize(); + }; + this.updateText = function() { + this.$loop.schedule(this.CHANGE_TEXT); + }; + this.updateFull = function(force) { + if (force) + this.$renderChanges(this.CHANGE_FULL, true); + else + this.$loop.schedule(this.CHANGE_FULL); + }; + this.updateFontSize = function() { + this.$textLayer.checkForSizeChanges(); + }; + + this.$changes = 0; + this.$updateSizeAsync = function() { + if (this.$loop.pending) + this.$size.$dirty = true; + else + this.onResize(); + }; + this.onResize = function(force, gutterWidth, width, height) { + if (this.resizing > 2) + return; + else if (this.resizing > 0) + this.resizing++; + else + this.resizing = force ? 1 : 0; + var el = this.container; + if (!height) + height = el.clientHeight || el.scrollHeight; + if (!width) + width = el.clientWidth || el.scrollWidth; + var changes = this.$updateCachedSize(force, gutterWidth, width, height); + + + if (!this.$size.scrollerHeight || (!width && !height)) + return this.resizing = 0; + + if (force) + this.$gutterLayer.$padding = null; + + if (force) + this.$renderChanges(changes | this.$changes, true); + else + this.$loop.schedule(changes | this.$changes); + + if (this.resizing) + this.resizing = 0; + this.scrollBarH.scrollLeft = this.scrollBarV.scrollTop = null; + }; + + this.$updateCachedSize = function(force, gutterWidth, width, height) { + height -= (this.$extraHeight || 0); + var changes = 0; + var size = this.$size; + var oldSize = { + width: size.width, + height: size.height, + scrollerHeight: size.scrollerHeight, + scrollerWidth: size.scrollerWidth + }; + if (height && (force || size.height != height)) { + size.height = height; + changes |= this.CHANGE_SIZE; + + size.scrollerHeight = size.height; + if (this.$horizScroll) + size.scrollerHeight -= this.scrollBarH.getHeight(); + this.scrollBarV.element.style.bottom = this.scrollBarH.getHeight() + "px"; + + changes = changes | this.CHANGE_SCROLL; + } + + if (width && (force || size.width != width)) { + changes |= this.CHANGE_SIZE; + size.width = width; + + if (gutterWidth == null) + gutterWidth = this.$showGutter ? this.$gutter.offsetWidth : 0; + + this.gutterWidth = gutterWidth; + + dom.setStyle(this.scrollBarH.element.style, "left", gutterWidth + "px"); + dom.setStyle(this.scroller.style, "left", gutterWidth + this.margin.left + "px"); + size.scrollerWidth = Math.max(0, width - gutterWidth - this.scrollBarV.getWidth() - this.margin.h); + dom.setStyle(this.$gutter.style, "left", this.margin.left + "px"); + + var right = this.scrollBarV.getWidth() + "px"; + dom.setStyle(this.scrollBarH.element.style, "right", right); + dom.setStyle(this.scroller.style, "right", right); + dom.setStyle(this.scroller.style, "bottom", this.scrollBarH.getHeight()); + + if (this.session && this.session.getUseWrapMode() && this.adjustWrapLimit() || force) { + changes |= this.CHANGE_FULL; + } + } + + size.$dirty = !width || !height; + + if (changes) + this._signal("resize", oldSize); + + return changes; + }; + + this.onGutterResize = function(width) { + var gutterWidth = this.$showGutter ? width : 0; + if (gutterWidth != this.gutterWidth) + this.$changes |= this.$updateCachedSize(true, gutterWidth, this.$size.width, this.$size.height); + + if (this.session.getUseWrapMode() && this.adjustWrapLimit()) { + this.$loop.schedule(this.CHANGE_FULL); + } else if (this.$size.$dirty) { + this.$loop.schedule(this.CHANGE_FULL); + } else { + this.$computeLayerConfig(); + } + }; + this.adjustWrapLimit = function() { + var availableWidth = this.$size.scrollerWidth - this.$padding * 2; + var limit = Math.floor(availableWidth / this.characterWidth); + return this.session.adjustWrapLimit(limit, this.$showPrintMargin && this.$printMarginColumn); + }; + this.setAnimatedScroll = function(shouldAnimate){ + this.setOption("animatedScroll", shouldAnimate); + }; + this.getAnimatedScroll = function() { + return this.$animatedScroll; + }; + this.setShowInvisibles = function(showInvisibles) { + this.setOption("showInvisibles", showInvisibles); + this.session.$bidiHandler.setShowInvisibles(showInvisibles); + }; + this.getShowInvisibles = function() { + return this.getOption("showInvisibles"); + }; + this.getDisplayIndentGuides = function() { + return this.getOption("displayIndentGuides"); + }; + + this.setDisplayIndentGuides = function(display) { + this.setOption("displayIndentGuides", display); + }; + this.setShowPrintMargin = function(showPrintMargin) { + this.setOption("showPrintMargin", showPrintMargin); + }; + this.getShowPrintMargin = function() { + return this.getOption("showPrintMargin"); + }; + this.setPrintMarginColumn = function(showPrintMargin) { + this.setOption("printMarginColumn", showPrintMargin); + }; + this.getPrintMarginColumn = function() { + return this.getOption("printMarginColumn"); + }; + this.getShowGutter = function(){ + return this.getOption("showGutter"); + }; + this.setShowGutter = function(show){ + return this.setOption("showGutter", show); + }; + + this.getFadeFoldWidgets = function(){ + return this.getOption("fadeFoldWidgets"); + }; + + this.setFadeFoldWidgets = function(show) { + this.setOption("fadeFoldWidgets", show); + }; + + this.setHighlightGutterLine = function(shouldHighlight) { + this.setOption("highlightGutterLine", shouldHighlight); + }; + + this.getHighlightGutterLine = function() { + return this.getOption("highlightGutterLine"); + }; + + this.$updatePrintMargin = function() { + if (!this.$showPrintMargin && !this.$printMarginEl) + return; + + if (!this.$printMarginEl) { + var containerEl = dom.createElement("div"); + containerEl.className = "ace_layer ace_print-margin-layer"; + this.$printMarginEl = dom.createElement("div"); + this.$printMarginEl.className = "ace_print-margin"; + containerEl.appendChild(this.$printMarginEl); + this.content.insertBefore(containerEl, this.content.firstChild); + } + + var style = this.$printMarginEl.style; + style.left = Math.round(this.characterWidth * this.$printMarginColumn + this.$padding) + "px"; + style.visibility = this.$showPrintMargin ? "visible" : "hidden"; + + if (this.session && this.session.$wrap == -1) + this.adjustWrapLimit(); + }; + this.getContainerElement = function() { + return this.container; + }; + this.getMouseEventTarget = function() { + return this.scroller; + }; + this.getTextAreaContainer = function() { + return this.container; + }; + this.$moveTextAreaToCursor = function() { + if (this.$isMousePressed) return; + var style = this.textarea.style; + var composition = this.$composition; + if (!this.$keepTextAreaAtCursor && !composition) { + dom.translate(this.textarea, -100, 0); + return; + } + var pixelPos = this.$cursorLayer.$pixelPos; + if (!pixelPos) + return; + if (composition && composition.markerRange) + pixelPos = this.$cursorLayer.getPixelPosition(composition.markerRange.start, true); + + var config = this.layerConfig; + var posTop = pixelPos.top; + var posLeft = pixelPos.left; + posTop -= config.offset; + + var h = composition && composition.useTextareaForIME ? this.lineHeight : HIDE_TEXTAREA ? 0 : 1; + if (posTop < 0 || posTop > config.height - h) { + dom.translate(this.textarea, 0, 0); + return; + } + + var w = 1; + var maxTop = this.$size.height - h; + if (!composition) { + posTop += this.lineHeight; + } + else { + if (composition.useTextareaForIME) { + var val = this.textarea.value; + w = this.characterWidth * (this.session.$getStringScreenWidth(val)[0]); + } + else { + posTop += this.lineHeight + 2; + } + } + + posLeft -= this.scrollLeft; + if (posLeft > this.$size.scrollerWidth - w) + posLeft = this.$size.scrollerWidth - w; + + posLeft += this.gutterWidth + this.margin.left; + + dom.setStyle(style, "height", h + "px"); + dom.setStyle(style, "width", w + "px"); + dom.translate(this.textarea, Math.min(posLeft, this.$size.scrollerWidth - w), Math.min(posTop, maxTop)); + }; + this.getFirstVisibleRow = function() { + return this.layerConfig.firstRow; + }; + this.getFirstFullyVisibleRow = function() { + return this.layerConfig.firstRow + (this.layerConfig.offset === 0 ? 0 : 1); + }; + this.getLastFullyVisibleRow = function() { + var config = this.layerConfig; + var lastRow = config.lastRow; + var top = this.session.documentToScreenRow(lastRow, 0) * config.lineHeight; + if (top - this.session.getScrollTop() > config.height - config.lineHeight) + return lastRow - 1; + return lastRow; + }; + this.getLastVisibleRow = function() { + return this.layerConfig.lastRow; + }; + + this.$padding = null; + this.setPadding = function(padding) { + this.$padding = padding; + this.$textLayer.setPadding(padding); + this.$cursorLayer.setPadding(padding); + this.$markerFront.setPadding(padding); + this.$markerBack.setPadding(padding); + this.$loop.schedule(this.CHANGE_FULL); + this.$updatePrintMargin(); + }; + + this.setScrollMargin = function(top, bottom, left, right) { + var sm = this.scrollMargin; + sm.top = top|0; + sm.bottom = bottom|0; + sm.right = right|0; + sm.left = left|0; + sm.v = sm.top + sm.bottom; + sm.h = sm.left + sm.right; + if (sm.top && this.scrollTop <= 0 && this.session) + this.session.setScrollTop(-sm.top); + this.updateFull(); + }; + + this.setMargin = function(top, bottom, left, right) { + var sm = this.margin; + sm.top = top|0; + sm.bottom = bottom|0; + sm.right = right|0; + sm.left = left|0; + sm.v = sm.top + sm.bottom; + sm.h = sm.left + sm.right; + this.$updateCachedSize(true, this.gutterWidth, this.$size.width, this.$size.height); + this.updateFull(); + }; + this.getHScrollBarAlwaysVisible = function() { + return this.$hScrollBarAlwaysVisible; + }; + this.setHScrollBarAlwaysVisible = function(alwaysVisible) { + this.setOption("hScrollBarAlwaysVisible", alwaysVisible); + }; + this.getVScrollBarAlwaysVisible = function() { + return this.$vScrollBarAlwaysVisible; + }; + this.setVScrollBarAlwaysVisible = function(alwaysVisible) { + this.setOption("vScrollBarAlwaysVisible", alwaysVisible); + }; + + this.$updateScrollBarV = function() { + var scrollHeight = this.layerConfig.maxHeight; + var scrollerHeight = this.$size.scrollerHeight; + if (!this.$maxLines && this.$scrollPastEnd) { + scrollHeight -= (scrollerHeight - this.lineHeight) * this.$scrollPastEnd; + if (this.scrollTop > scrollHeight - scrollerHeight) { + scrollHeight = this.scrollTop + scrollerHeight; + this.scrollBarV.scrollTop = null; + } + } + this.scrollBarV.setScrollHeight(scrollHeight + this.scrollMargin.v); + this.scrollBarV.setScrollTop(this.scrollTop + this.scrollMargin.top); + }; + this.$updateScrollBarH = function() { + this.scrollBarH.setScrollWidth(this.layerConfig.width + 2 * this.$padding + this.scrollMargin.h); + this.scrollBarH.setScrollLeft(this.scrollLeft + this.scrollMargin.left); + }; + + this.$frozen = false; + this.freeze = function() { + this.$frozen = true; + }; + + this.unfreeze = function() { + this.$frozen = false; + }; + + this.$renderChanges = function(changes, force) { + if (this.$changes) { + changes |= this.$changes; + this.$changes = 0; + } + if ((!this.session || !this.container.offsetWidth || this.$frozen) || (!changes && !force)) { + this.$changes |= changes; + return; + } + if (this.$size.$dirty) { + this.$changes |= changes; + return this.onResize(true); + } + if (!this.lineHeight) { + this.$textLayer.checkForSizeChanges(); + } + + this._signal("beforeRender", changes); + + if (this.session && this.session.$bidiHandler) + this.session.$bidiHandler.updateCharacterWidths(this.$fontMetrics); + + var config = this.layerConfig; + if (changes & this.CHANGE_FULL || + changes & this.CHANGE_SIZE || + changes & this.CHANGE_TEXT || + changes & this.CHANGE_LINES || + changes & this.CHANGE_SCROLL || + changes & this.CHANGE_H_SCROLL + ) { + changes |= this.$computeLayerConfig() | this.$loop.clear(); + if (config.firstRow != this.layerConfig.firstRow && config.firstRowScreen == this.layerConfig.firstRowScreen) { + var st = this.scrollTop + (config.firstRow - this.layerConfig.firstRow) * this.lineHeight; + if (st > 0) { + this.scrollTop = st; + changes = changes | this.CHANGE_SCROLL; + changes |= this.$computeLayerConfig() | this.$loop.clear(); + } + } + config = this.layerConfig; + this.$updateScrollBarV(); + if (changes & this.CHANGE_H_SCROLL) + this.$updateScrollBarH(); + + dom.translate(this.content, -this.scrollLeft, -config.offset); + + var width = config.width + 2 * this.$padding + "px"; + var height = config.minHeight + "px"; + + dom.setStyle(this.content.style, "width", width); + dom.setStyle(this.content.style, "height", height); + } + if (changes & this.CHANGE_H_SCROLL) { + dom.translate(this.content, -this.scrollLeft, -config.offset); + this.scroller.className = this.scrollLeft <= 0 ? "ace_scroller" : "ace_scroller ace_scroll-left"; + } + if (changes & this.CHANGE_FULL) { + this.$changedLines = null; + this.$textLayer.update(config); + if (this.$showGutter) + this.$gutterLayer.update(config); + this.$markerBack.update(config); + this.$markerFront.update(config); + this.$cursorLayer.update(config); + this.$moveTextAreaToCursor(); + this._signal("afterRender", changes); + return; + } + if (changes & this.CHANGE_SCROLL) { + this.$changedLines = null; + if (changes & this.CHANGE_TEXT || changes & this.CHANGE_LINES) + this.$textLayer.update(config); + else + this.$textLayer.scrollLines(config); + + if (this.$showGutter) { + if (changes & this.CHANGE_GUTTER || changes & this.CHANGE_LINES) + this.$gutterLayer.update(config); + else + this.$gutterLayer.scrollLines(config); + } + this.$markerBack.update(config); + this.$markerFront.update(config); + this.$cursorLayer.update(config); + this.$moveTextAreaToCursor(); + this._signal("afterRender", changes); + return; + } + + if (changes & this.CHANGE_TEXT) { + this.$changedLines = null; + this.$textLayer.update(config); + if (this.$showGutter) + this.$gutterLayer.update(config); + } + else if (changes & this.CHANGE_LINES) { + if (this.$updateLines() || (changes & this.CHANGE_GUTTER) && this.$showGutter) + this.$gutterLayer.update(config); + } + else if (changes & this.CHANGE_TEXT || changes & this.CHANGE_GUTTER) { + if (this.$showGutter) + this.$gutterLayer.update(config); + } + else if (changes & this.CHANGE_CURSOR) { + if (this.$highlightGutterLine) + this.$gutterLayer.updateLineHighlight(config); + } + + if (changes & this.CHANGE_CURSOR) { + this.$cursorLayer.update(config); + this.$moveTextAreaToCursor(); + } + + if (changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_FRONT)) { + this.$markerFront.update(config); + } + + if (changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_BACK)) { + this.$markerBack.update(config); + } + + this._signal("afterRender", changes); + }; + + + this.$autosize = function() { + var height = this.session.getScreenLength() * this.lineHeight; + var maxHeight = this.$maxLines * this.lineHeight; + var desiredHeight = Math.min(maxHeight, + Math.max((this.$minLines || 1) * this.lineHeight, height) + ) + this.scrollMargin.v + (this.$extraHeight || 0); + if (this.$horizScroll) + desiredHeight += this.scrollBarH.getHeight(); + if (this.$maxPixelHeight && desiredHeight > this.$maxPixelHeight) + desiredHeight = this.$maxPixelHeight; + + var hideScrollbars = desiredHeight <= 2 * this.lineHeight; + var vScroll = !hideScrollbars && height > maxHeight; + + if (desiredHeight != this.desiredHeight || + this.$size.height != this.desiredHeight || vScroll != this.$vScroll) { + if (vScroll != this.$vScroll) { + this.$vScroll = vScroll; + this.scrollBarV.setVisible(vScroll); + } + + var w = this.container.clientWidth; + this.container.style.height = desiredHeight + "px"; + this.$updateCachedSize(true, this.$gutterWidth, w, desiredHeight); + this.desiredHeight = desiredHeight; + + this._signal("autosize"); + } + }; + + this.$computeLayerConfig = function() { + var session = this.session; + var size = this.$size; + + var hideScrollbars = size.height <= 2 * this.lineHeight; + var screenLines = this.session.getScreenLength(); + var maxHeight = screenLines * this.lineHeight; + + var longestLine = this.$getLongestLine(); + + var horizScroll = !hideScrollbars && (this.$hScrollBarAlwaysVisible || + size.scrollerWidth - longestLine - 2 * this.$padding < 0); + + var hScrollChanged = this.$horizScroll !== horizScroll; + if (hScrollChanged) { + this.$horizScroll = horizScroll; + this.scrollBarH.setVisible(horizScroll); + } + var vScrollBefore = this.$vScroll; // autosize can change vscroll value in which case we need to update longestLine + if (this.$maxLines && this.lineHeight > 1) + this.$autosize(); + + var minHeight = size.scrollerHeight + this.lineHeight; + + var scrollPastEnd = !this.$maxLines && this.$scrollPastEnd + ? (size.scrollerHeight - this.lineHeight) * this.$scrollPastEnd + : 0; + maxHeight += scrollPastEnd; + + var sm = this.scrollMargin; + this.session.setScrollTop(Math.max(-sm.top, + Math.min(this.scrollTop, maxHeight - size.scrollerHeight + sm.bottom))); + + this.session.setScrollLeft(Math.max(-sm.left, Math.min(this.scrollLeft, + longestLine + 2 * this.$padding - size.scrollerWidth + sm.right))); + + var vScroll = !hideScrollbars && (this.$vScrollBarAlwaysVisible || + size.scrollerHeight - maxHeight + scrollPastEnd < 0 || this.scrollTop > sm.top); + var vScrollChanged = vScrollBefore !== vScroll; + if (vScrollChanged) { + this.$vScroll = vScroll; + this.scrollBarV.setVisible(vScroll); + } + + var offset = this.scrollTop % this.lineHeight; + var lineCount = Math.ceil(minHeight / this.lineHeight) - 1; + var firstRow = Math.max(0, Math.round((this.scrollTop - offset) / this.lineHeight)); + var lastRow = firstRow + lineCount; + var firstRowScreen, firstRowHeight; + var lineHeight = this.lineHeight; + firstRow = session.screenToDocumentRow(firstRow, 0); + var foldLine = session.getFoldLine(firstRow); + if (foldLine) { + firstRow = foldLine.start.row; + } + + firstRowScreen = session.documentToScreenRow(firstRow, 0); + firstRowHeight = session.getRowLength(firstRow) * lineHeight; + + lastRow = Math.min(session.screenToDocumentRow(lastRow, 0), session.getLength() - 1); + minHeight = size.scrollerHeight + session.getRowLength(lastRow) * lineHeight + + firstRowHeight; + + offset = this.scrollTop - firstRowScreen * lineHeight; + + var changes = 0; + if (this.layerConfig.width != longestLine || hScrollChanged) + changes = this.CHANGE_H_SCROLL; + if (hScrollChanged || vScrollChanged) { + changes |= this.$updateCachedSize(true, this.gutterWidth, size.width, size.height); + this._signal("scrollbarVisibilityChanged"); + if (vScrollChanged) + longestLine = this.$getLongestLine(); + } + + this.layerConfig = { + width : longestLine, + padding : this.$padding, + firstRow : firstRow, + firstRowScreen: firstRowScreen, + lastRow : lastRow, + lineHeight : lineHeight, + characterWidth : this.characterWidth, + minHeight : minHeight, + maxHeight : maxHeight, + offset : offset, + gutterOffset : lineHeight ? Math.max(0, Math.ceil((offset + size.height - size.scrollerHeight) / lineHeight)) : 0, + height : this.$size.scrollerHeight + }; + + if (this.session.$bidiHandler) + this.session.$bidiHandler.setContentWidth(longestLine - this.$padding); + + return changes; + }; + + this.$updateLines = function() { + if (!this.$changedLines) return; + var firstRow = this.$changedLines.firstRow; + var lastRow = this.$changedLines.lastRow; + this.$changedLines = null; + + var layerConfig = this.layerConfig; + + if (firstRow > layerConfig.lastRow + 1) { return; } + if (lastRow < layerConfig.firstRow) { return; } + if (lastRow === Infinity) { + if (this.$showGutter) + this.$gutterLayer.update(layerConfig); + this.$textLayer.update(layerConfig); + return; + } + this.$textLayer.updateLines(layerConfig, firstRow, lastRow); + return true; + }; + + this.$getLongestLine = function() { + var charCount = this.session.getScreenWidth(); + if (this.showInvisibles && !this.session.$useWrapMode) + charCount += 1; + + if (this.$textLayer && charCount > this.$textLayer.MAX_LINE_LENGTH) + charCount = this.$textLayer.MAX_LINE_LENGTH + 30; + + return Math.max(this.$size.scrollerWidth - 2 * this.$padding, Math.round(charCount * this.characterWidth)); + }; + this.updateFrontMarkers = function() { + this.$markerFront.setMarkers(this.session.getMarkers(true)); + this.$loop.schedule(this.CHANGE_MARKER_FRONT); + }; + this.updateBackMarkers = function() { + this.$markerBack.setMarkers(this.session.getMarkers()); + this.$loop.schedule(this.CHANGE_MARKER_BACK); + }; + this.addGutterDecoration = function(row, className){ + this.$gutterLayer.addGutterDecoration(row, className); + }; + this.removeGutterDecoration = function(row, className){ + this.$gutterLayer.removeGutterDecoration(row, className); + }; + this.updateBreakpoints = function(rows) { + this.$loop.schedule(this.CHANGE_GUTTER); + }; + this.setAnnotations = function(annotations) { + this.$gutterLayer.setAnnotations(annotations); + this.$loop.schedule(this.CHANGE_GUTTER); + }; + this.updateCursor = function() { + this.$loop.schedule(this.CHANGE_CURSOR); + }; + this.hideCursor = function() { + this.$cursorLayer.hideCursor(); + }; + this.showCursor = function() { + this.$cursorLayer.showCursor(); + }; + + this.scrollSelectionIntoView = function(anchor, lead, offset) { + this.scrollCursorIntoView(anchor, offset); + this.scrollCursorIntoView(lead, offset); + }; + this.scrollCursorIntoView = function(cursor, offset, $viewMargin) { + if (this.$size.scrollerHeight === 0) + return; + + var pos = this.$cursorLayer.getPixelPosition(cursor); + + var left = pos.left; + var top = pos.top; + + var topMargin = $viewMargin && $viewMargin.top || 0; + var bottomMargin = $viewMargin && $viewMargin.bottom || 0; + + var scrollTop = this.$scrollAnimation ? this.session.getScrollTop() : this.scrollTop; + + if (scrollTop + topMargin > top) { + if (offset && scrollTop + topMargin > top + this.lineHeight) + top -= offset * this.$size.scrollerHeight; + if (top === 0) + top = -this.scrollMargin.top; + this.session.setScrollTop(top); + } else if (scrollTop + this.$size.scrollerHeight - bottomMargin < top + this.lineHeight) { + if (offset && scrollTop + this.$size.scrollerHeight - bottomMargin < top - this.lineHeight) + top += offset * this.$size.scrollerHeight; + this.session.setScrollTop(top + this.lineHeight + bottomMargin - this.$size.scrollerHeight); + } + + var scrollLeft = this.scrollLeft; + + if (scrollLeft > left) { + if (left < this.$padding + 2 * this.layerConfig.characterWidth) + left = -this.scrollMargin.left; + this.session.setScrollLeft(left); + } else if (scrollLeft + this.$size.scrollerWidth < left + this.characterWidth) { + this.session.setScrollLeft(Math.round(left + this.characterWidth - this.$size.scrollerWidth)); + } else if (scrollLeft <= this.$padding && left - scrollLeft < this.characterWidth) { + this.session.setScrollLeft(0); + } + }; + this.getScrollTop = function() { + return this.session.getScrollTop(); + }; + this.getScrollLeft = function() { + return this.session.getScrollLeft(); + }; + this.getScrollTopRow = function() { + return this.scrollTop / this.lineHeight; + }; + this.getScrollBottomRow = function() { + return Math.max(0, Math.floor((this.scrollTop + this.$size.scrollerHeight) / this.lineHeight) - 1); + }; + this.scrollToRow = function(row) { + this.session.setScrollTop(row * this.lineHeight); + }; + + this.alignCursor = function(cursor, alignment) { + if (typeof cursor == "number") + cursor = {row: cursor, column: 0}; + + var pos = this.$cursorLayer.getPixelPosition(cursor); + var h = this.$size.scrollerHeight - this.lineHeight; + var offset = pos.top - h * (alignment || 0); + + this.session.setScrollTop(offset); + return offset; + }; + + this.STEPS = 8; + this.$calcSteps = function(fromValue, toValue){ + var i = 0; + var l = this.STEPS; + var steps = []; + + var func = function(t, x_min, dx) { + return dx * (Math.pow(t - 1, 3) + 1) + x_min; + }; + + for (i = 0; i < l; ++i) + steps.push(func(i / this.STEPS, fromValue, toValue - fromValue)); + + return steps; + }; + this.scrollToLine = function(line, center, animate, callback) { + var pos = this.$cursorLayer.getPixelPosition({row: line, column: 0}); + var offset = pos.top; + if (center) + offset -= this.$size.scrollerHeight / 2; + + var initialScroll = this.scrollTop; + this.session.setScrollTop(offset); + if (animate !== false) + this.animateScrolling(initialScroll, callback); + }; + + this.animateScrolling = function(fromValue, callback) { + var toValue = this.scrollTop; + if (!this.$animatedScroll) + return; + var _self = this; + + if (fromValue == toValue) + return; + + if (this.$scrollAnimation) { + var oldSteps = this.$scrollAnimation.steps; + if (oldSteps.length) { + fromValue = oldSteps[0]; + if (fromValue == toValue) + return; + } + } + + var steps = _self.$calcSteps(fromValue, toValue); + this.$scrollAnimation = {from: fromValue, to: toValue, steps: steps}; + + clearInterval(this.$timer); + + _self.session.setScrollTop(steps.shift()); + _self.session.$scrollTop = toValue; + this.$timer = setInterval(function() { + if (!_self.session) + return clearInterval(_self.$timer); + if (steps.length) { + _self.session.setScrollTop(steps.shift()); + _self.session.$scrollTop = toValue; + } else if (toValue != null) { + _self.session.$scrollTop = -1; + _self.session.setScrollTop(toValue); + toValue = null; + } else { + _self.$timer = clearInterval(_self.$timer); + _self.$scrollAnimation = null; + callback && callback(); + } + }, 10); + }; + this.scrollToY = function(scrollTop) { + if (this.scrollTop !== scrollTop) { + this.$loop.schedule(this.CHANGE_SCROLL); + this.scrollTop = scrollTop; + } + }; + this.scrollToX = function(scrollLeft) { + if (this.scrollLeft !== scrollLeft) + this.scrollLeft = scrollLeft; + this.$loop.schedule(this.CHANGE_H_SCROLL); + }; + this.scrollTo = function(x, y) { + this.session.setScrollTop(y); + this.session.setScrollLeft(x); + }; + this.scrollBy = function(deltaX, deltaY) { + deltaY && this.session.setScrollTop(this.session.getScrollTop() + deltaY); + deltaX && this.session.setScrollLeft(this.session.getScrollLeft() + deltaX); + }; + this.isScrollableBy = function(deltaX, deltaY) { + if (deltaY < 0 && this.session.getScrollTop() >= 1 - this.scrollMargin.top) + return true; + if (deltaY > 0 && this.session.getScrollTop() + this.$size.scrollerHeight + - this.layerConfig.maxHeight < -1 + this.scrollMargin.bottom) + return true; + if (deltaX < 0 && this.session.getScrollLeft() >= 1 - this.scrollMargin.left) + return true; + if (deltaX > 0 && this.session.getScrollLeft() + this.$size.scrollerWidth + - this.layerConfig.width < -1 + this.scrollMargin.right) + return true; + }; + + this.pixelToScreenCoordinates = function(x, y) { + var canvasPos; + if (this.$hasCssTransforms) { + canvasPos = {top:0, left: 0}; + var p = this.$fontMetrics.transformCoordinates([x, y]); + x = p[1] - this.gutterWidth - this.margin.left; + y = p[0]; + } else { + canvasPos = this.scroller.getBoundingClientRect(); + } + + var offsetX = x + this.scrollLeft - canvasPos.left - this.$padding; + var offset = offsetX / this.characterWidth; + var row = Math.floor((y + this.scrollTop - canvasPos.top) / this.lineHeight); + var col = this.$blockCursor ? Math.floor(offset) : Math.round(offset); + + return {row: row, column: col, side: offset - col > 0 ? 1 : -1, offsetX: offsetX}; + }; + + this.screenToTextCoordinates = function(x, y) { + var canvasPos; + if (this.$hasCssTransforms) { + canvasPos = {top:0, left: 0}; + var p = this.$fontMetrics.transformCoordinates([x, y]); + x = p[1] - this.gutterWidth - this.margin.left; + y = p[0]; + } else { + canvasPos = this.scroller.getBoundingClientRect(); + } + + var offsetX = x + this.scrollLeft - canvasPos.left - this.$padding; + var offset = offsetX / this.characterWidth; + var col = this.$blockCursor ? Math.floor(offset) : Math.round(offset); + + var row = Math.floor((y + this.scrollTop - canvasPos.top) / this.lineHeight); + + return this.session.screenToDocumentPosition(row, Math.max(col, 0), offsetX); + }; + this.textToScreenCoordinates = function(row, column) { + var canvasPos = this.scroller.getBoundingClientRect(); + var pos = this.session.documentToScreenPosition(row, column); + + var x = this.$padding + (this.session.$bidiHandler.isBidiRow(pos.row, row) + ? this.session.$bidiHandler.getPosLeft(pos.column) + : Math.round(pos.column * this.characterWidth)); + + var y = pos.row * this.lineHeight; + + return { + pageX: canvasPos.left + x - this.scrollLeft, + pageY: canvasPos.top + y - this.scrollTop + }; + }; + this.visualizeFocus = function() { + dom.addCssClass(this.container, "ace_focus"); + }; + this.visualizeBlur = function() { + dom.removeCssClass(this.container, "ace_focus"); + }; + this.showComposition = function(composition) { + this.$composition = composition; + if (!composition.cssText) { + composition.cssText = this.textarea.style.cssText; + } + if (composition.useTextareaForIME == undefined) + composition.useTextareaForIME = this.$useTextareaForIME; + + if (this.$useTextareaForIME) { + dom.addCssClass(this.textarea, "ace_composition"); + this.textarea.style.cssText = ""; + this.$moveTextAreaToCursor(); + this.$cursorLayer.element.style.display = "none"; + } + else { + composition.markerId = this.session.addMarker(composition.markerRange, "ace_composition_marker", "text"); + } + }; + this.setCompositionText = function(text) { + var cursor = this.session.selection.cursor; + this.addToken(text, "composition_placeholder", cursor.row, cursor.column); + this.$moveTextAreaToCursor(); + }; + this.hideComposition = function() { + if (!this.$composition) + return; + + if (this.$composition.markerId) + this.session.removeMarker(this.$composition.markerId); + + dom.removeCssClass(this.textarea, "ace_composition"); + this.textarea.style.cssText = this.$composition.cssText; + var cursor = this.session.selection.cursor; + this.removeExtraToken(cursor.row, cursor.column); + this.$composition = null; + this.$cursorLayer.element.style.display = ""; + }; + + this.addToken = function(text, type, row, column) { + var session = this.session; + session.bgTokenizer.lines[row] = null; + var newToken = {type: type, value: text}; + var tokens = session.getTokens(row); + if (column == null) { + tokens.push(newToken); + } else { + var l = 0; + for (var i =0; i < tokens.length; i++) { + var token = tokens[i]; + l += token.value.length; + if (column <= l) { + var diff = token.value.length - (l - column); + var before = token.value.slice(0, diff); + var after = token.value.slice(diff); + + tokens.splice(i, 1, {type: token.type, value: before}, newToken, {type: token.type, value: after}); + break; + } + } + } + this.updateLines(row, row); + }; + + this.removeExtraToken = function(row, column) { + this.updateLines(row, row); + }; + this.setTheme = function(theme, cb) { + var _self = this; + this.$themeId = theme; + _self._dispatchEvent('themeChange',{theme:theme}); + + if (!theme || typeof theme == "string") { + var moduleName = theme || this.$options.theme.initialValue; + config.loadModule(["theme", moduleName], afterLoad); + } else { + afterLoad(theme); + } + + function afterLoad(module) { + if (_self.$themeId != theme) + return cb && cb(); + if (!module || !module.cssClass) + throw new Error("couldn't load module " + theme + " or it didn't call define"); + if (module.$id) + _self.$themeId = module.$id; + dom.importCssString( + module.cssText, + module.cssClass, + _self.container + ); + + if (_self.theme) + dom.removeCssClass(_self.container, _self.theme.cssClass); + + var padding = "padding" in module ? module.padding + : "padding" in (_self.theme || {}) ? 4 : _self.$padding; + if (_self.$padding && padding != _self.$padding) + _self.setPadding(padding); + _self.$theme = module.cssClass; + + _self.theme = module; + dom.addCssClass(_self.container, module.cssClass); + dom.setCssClass(_self.container, "ace_dark", module.isDark); + if (_self.$size) { + _self.$size.width = 0; + _self.$updateSizeAsync(); + } + + _self._dispatchEvent('themeLoaded', {theme:module}); + cb && cb(); + } + }; + this.getTheme = function() { + return this.$themeId; + }; + this.setStyle = function(style, include) { + dom.setCssClass(this.container, style, include !== false); + }; + this.unsetStyle = function(style) { + dom.removeCssClass(this.container, style); + }; + + this.setCursorStyle = function(style) { + dom.setStyle(this.scroller.style, "cursor", style); + }; + this.setMouseCursor = function(cursorStyle) { + dom.setStyle(this.scroller.style, "cursor", cursorStyle); + }; + + this.attachToShadowRoot = function() { + dom.importCssString(editorCss, "ace_editor.css", this.container); + }; + this.destroy = function() { + this.freeze(); + this.$fontMetrics.destroy(); + this.$cursorLayer.destroy(); + this.removeAllListeners(); + this.container.textContent = ""; + }; + +}).call(VirtualRenderer.prototype); + + +config.defineOptions(VirtualRenderer.prototype, "renderer", { + animatedScroll: {initialValue: false}, + showInvisibles: { + set: function(value) { + if (this.$textLayer.setShowInvisibles(value)) + this.$loop.schedule(this.CHANGE_TEXT); + }, + initialValue: false + }, + showPrintMargin: { + set: function() { this.$updatePrintMargin(); }, + initialValue: true + }, + printMarginColumn: { + set: function() { this.$updatePrintMargin(); }, + initialValue: 80 + }, + printMargin: { + set: function(val) { + if (typeof val == "number") + this.$printMarginColumn = val; + this.$showPrintMargin = !!val; + this.$updatePrintMargin(); + }, + get: function() { + return this.$showPrintMargin && this.$printMarginColumn; + } + }, + showGutter: { + set: function(show){ + this.$gutter.style.display = show ? "block" : "none"; + this.$loop.schedule(this.CHANGE_FULL); + this.onGutterResize(); + }, + initialValue: true + }, + fadeFoldWidgets: { + set: function(show) { + dom.setCssClass(this.$gutter, "ace_fade-fold-widgets", show); + }, + initialValue: false + }, + showFoldWidgets: { + set: function(show) { + this.$gutterLayer.setShowFoldWidgets(show); + this.$loop.schedule(this.CHANGE_GUTTER); + }, + initialValue: true + }, + displayIndentGuides: { + set: function(show) { + if (this.$textLayer.setDisplayIndentGuides(show)) + this.$loop.schedule(this.CHANGE_TEXT); + }, + initialValue: true + }, + highlightGutterLine: { + set: function(shouldHighlight) { + this.$gutterLayer.setHighlightGutterLine(shouldHighlight); + this.$loop.schedule(this.CHANGE_GUTTER); + }, + initialValue: true + }, + hScrollBarAlwaysVisible: { + set: function(val) { + if (!this.$hScrollBarAlwaysVisible || !this.$horizScroll) + this.$loop.schedule(this.CHANGE_SCROLL); + }, + initialValue: false + }, + vScrollBarAlwaysVisible: { + set: function(val) { + if (!this.$vScrollBarAlwaysVisible || !this.$vScroll) + this.$loop.schedule(this.CHANGE_SCROLL); + }, + initialValue: false + }, + fontSize: { + set: function(size) { + if (typeof size == "number") + size = size + "px"; + this.container.style.fontSize = size; + this.updateFontSize(); + }, + initialValue: 12 + }, + fontFamily: { + set: function(name) { + this.container.style.fontFamily = name; + this.updateFontSize(); + } + }, + maxLines: { + set: function(val) { + this.updateFull(); + } + }, + minLines: { + set: function(val) { + if (!(this.$minLines < 0x1ffffffffffff)) + this.$minLines = 0; + this.updateFull(); + } + }, + maxPixelHeight: { + set: function(val) { + this.updateFull(); + }, + initialValue: 0 + }, + scrollPastEnd: { + set: function(val) { + val = +val || 0; + if (this.$scrollPastEnd == val) + return; + this.$scrollPastEnd = val; + this.$loop.schedule(this.CHANGE_SCROLL); + }, + initialValue: 0, + handlesSet: true + }, + fixedWidthGutter: { + set: function(val) { + this.$gutterLayer.$fixedWidth = !!val; + this.$loop.schedule(this.CHANGE_GUTTER); + } + }, + theme: { + set: function(val) { this.setTheme(val); }, + get: function() { return this.$themeId || this.theme; }, + initialValue: "./theme/textmate", + handlesSet: true + }, + hasCssTransforms: { + }, + useTextareaForIME: { + initialValue: !useragent.isMobile && !useragent.isIE + } +}); + +exports.VirtualRenderer = VirtualRenderer; +}); + +ace.define("ace/worker/worker_client",["require","exports","module","ace/lib/oop","ace/lib/net","ace/lib/event_emitter","ace/config"], function(require, exports, module) { +"use strict"; + +var oop = require("../lib/oop"); +var net = require("../lib/net"); +var EventEmitter = require("../lib/event_emitter").EventEmitter; +var config = require("../config"); + +function $workerBlob(workerUrl) { + var script = "importScripts('" + net.qualifyURL(workerUrl) + "');"; + try { + return new Blob([script], {"type": "application/javascript"}); + } catch (e) { // Backwards-compatibility + var BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder; + var blobBuilder = new BlobBuilder(); + blobBuilder.append(script); + return blobBuilder.getBlob("application/javascript"); + } +} + +function createWorker(workerUrl) { + if (typeof Worker == "undefined") + return { postMessage: function() {}, terminate: function() {} }; + if (config.get("loadWorkerFromBlob")) { + var blob = $workerBlob(workerUrl); + var URL = window.URL || window.webkitURL; + var blobURL = URL.createObjectURL(blob); + return new Worker(blobURL); + } + return new Worker(workerUrl); +} + +var WorkerClient = function(worker) { + if (!worker.postMessage) + worker = this.$createWorkerFromOldConfig.apply(this, arguments); + + this.$worker = worker; + this.$sendDeltaQueue = this.$sendDeltaQueue.bind(this); + this.changeListener = this.changeListener.bind(this); + this.onMessage = this.onMessage.bind(this); + + this.callbackId = 1; + this.callbacks = {}; + + this.$worker.onmessage = this.onMessage; +}; + +(function(){ + + oop.implement(this, EventEmitter); + + this.$createWorkerFromOldConfig = function(topLevelNamespaces, mod, classname, workerUrl, importScripts) { + if (require.nameToUrl && !require.toUrl) + require.toUrl = require.nameToUrl; + + if (config.get("packaged") || !require.toUrl) { + workerUrl = workerUrl || config.moduleUrl(mod, "worker"); + } else { + var normalizePath = this.$normalizePath; + workerUrl = workerUrl || normalizePath(require.toUrl("ace/worker/worker.js", null, "_")); + + var tlns = {}; + topLevelNamespaces.forEach(function(ns) { + tlns[ns] = normalizePath(require.toUrl(ns, null, "_").replace(/(\.js)?(\?.*)?$/, "")); + }); + } + + this.$worker = createWorker(workerUrl); + if (importScripts) { + this.send("importScripts", importScripts); + } + this.$worker.postMessage({ + init : true, + tlns : tlns, + module : mod, + classname : classname + }); + return this.$worker; + }; + + this.onMessage = function(e) { + var msg = e.data; + switch (msg.type) { + case "event": + this._signal(msg.name, {data: msg.data}); + break; + case "call": + var callback = this.callbacks[msg.id]; + if (callback) { + callback(msg.data); + delete this.callbacks[msg.id]; + } + break; + case "error": + this.reportError(msg.data); + break; + case "log": + window.console && console.log && console.log.apply(console, msg.data); + break; + } + }; + + this.reportError = function(err) { + window.console && console.error && console.error(err); + }; + + this.$normalizePath = function(path) { + return net.qualifyURL(path); + }; + + this.terminate = function() { + this._signal("terminate", {}); + this.deltaQueue = null; + this.$worker.terminate(); + this.$worker = null; + if (this.$doc) + this.$doc.off("change", this.changeListener); + this.$doc = null; + }; + + this.send = function(cmd, args) { + this.$worker.postMessage({command: cmd, args: args}); + }; + + this.call = function(cmd, args, callback) { + if (callback) { + var id = this.callbackId++; + this.callbacks[id] = callback; + args.push(id); + } + this.send(cmd, args); + }; + + this.emit = function(event, data) { + try { + if (data.data && data.data.err) + data.data.err = {message: data.data.err.message, stack: data.data.err.stack, code: data.data.err.code}; + this.$worker.postMessage({event: event, data: {data: data.data}}); + } + catch(ex) { + console.error(ex.stack); + } + }; + + this.attachToDocument = function(doc) { + if (this.$doc) + this.terminate(); + + this.$doc = doc; + this.call("setValue", [doc.getValue()]); + doc.on("change", this.changeListener); + }; + + this.changeListener = function(delta) { + if (!this.deltaQueue) { + this.deltaQueue = []; + setTimeout(this.$sendDeltaQueue, 0); + } + if (delta.action == "insert") + this.deltaQueue.push(delta.start, delta.lines); + else + this.deltaQueue.push(delta.start, delta.end); + }; + + this.$sendDeltaQueue = function() { + var q = this.deltaQueue; + if (!q) return; + this.deltaQueue = null; + if (q.length > 50 && q.length > this.$doc.getLength() >> 1) { + this.call("setValue", [this.$doc.getValue()]); + } else + this.emit("change", {data: q}); + }; + +}).call(WorkerClient.prototype); + + +var UIWorkerClient = function(topLevelNamespaces, mod, classname) { + var main = null; + var emitSync = false; + var sender = Object.create(EventEmitter); + + var messageBuffer = []; + var workerClient = new WorkerClient({ + messageBuffer: messageBuffer, + terminate: function() {}, + postMessage: function(e) { + messageBuffer.push(e); + if (!main) return; + if (emitSync) + setTimeout(processNext); + else + processNext(); + } + }); + + workerClient.setEmitSync = function(val) { emitSync = val; }; + + var processNext = function() { + var msg = messageBuffer.shift(); + if (msg.command) + main[msg.command].apply(main, msg.args); + else if (msg.event) + sender._signal(msg.event, msg.data); + }; + + sender.postMessage = function(msg) { + workerClient.onMessage({data: msg}); + }; + sender.callback = function(data, callbackId) { + this.postMessage({type: "call", id: callbackId, data: data}); + }; + sender.emit = function(name, data) { + this.postMessage({type: "event", name: name, data: data}); + }; + + config.loadModule(["worker", mod], function(Main) { + main = new Main[classname](sender); + while (messageBuffer.length) + processNext(); + }); + + return workerClient; +}; + +exports.UIWorkerClient = UIWorkerClient; +exports.WorkerClient = WorkerClient; +exports.createWorker = createWorker; + + +}); + +ace.define("ace/placeholder",["require","exports","module","ace/range","ace/lib/event_emitter","ace/lib/oop"], function(require, exports, module) { +"use strict"; + +var Range = require("./range").Range; +var EventEmitter = require("./lib/event_emitter").EventEmitter; +var oop = require("./lib/oop"); + +var PlaceHolder = function(session, length, pos, others, mainClass, othersClass) { + var _self = this; + this.length = length; + this.session = session; + this.doc = session.getDocument(); + this.mainClass = mainClass; + this.othersClass = othersClass; + this.$onUpdate = this.onUpdate.bind(this); + this.doc.on("change", this.$onUpdate); + this.$others = others; + + this.$onCursorChange = function() { + setTimeout(function() { + _self.onCursorChange(); + }); + }; + + this.$pos = pos; + var undoStack = session.getUndoManager().$undoStack || session.getUndoManager().$undostack || {length: -1}; + this.$undoStackDepth = undoStack.length; + this.setup(); + + session.selection.on("changeCursor", this.$onCursorChange); +}; + +(function() { + + oop.implement(this, EventEmitter); + this.setup = function() { + var _self = this; + var doc = this.doc; + var session = this.session; + + this.selectionBefore = session.selection.toJSON(); + if (session.selection.inMultiSelectMode) + session.selection.toSingleRange(); + + this.pos = doc.createAnchor(this.$pos.row, this.$pos.column); + var pos = this.pos; + pos.$insertRight = true; + pos.detach(); + pos.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column + this.length), this.mainClass, null, false); + this.others = []; + this.$others.forEach(function(other) { + var anchor = doc.createAnchor(other.row, other.column); + anchor.$insertRight = true; + anchor.detach(); + _self.others.push(anchor); + }); + session.setUndoSelect(false); + }; + this.showOtherMarkers = function() { + if (this.othersActive) return; + var session = this.session; + var _self = this; + this.othersActive = true; + this.others.forEach(function(anchor) { + anchor.markerId = session.addMarker(new Range(anchor.row, anchor.column, anchor.row, anchor.column+_self.length), _self.othersClass, null, false); + }); + }; + this.hideOtherMarkers = function() { + if (!this.othersActive) return; + this.othersActive = false; + for (var i = 0; i < this.others.length; i++) { + this.session.removeMarker(this.others[i].markerId); + } + }; + this.onUpdate = function(delta) { + if (this.$updating) + return this.updateAnchors(delta); + + var range = delta; + if (range.start.row !== range.end.row) return; + if (range.start.row !== this.pos.row) return; + this.$updating = true; + var lengthDiff = delta.action === "insert" ? range.end.column - range.start.column : range.start.column - range.end.column; + var inMainRange = range.start.column >= this.pos.column && range.start.column <= this.pos.column + this.length + 1; + var distanceFromStart = range.start.column - this.pos.column; + + this.updateAnchors(delta); + + if (inMainRange) + this.length += lengthDiff; + + if (inMainRange && !this.session.$fromUndo) { + if (delta.action === 'insert') { + for (var i = this.others.length - 1; i >= 0; i--) { + var otherPos = this.others[i]; + var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart}; + this.doc.insertMergedLines(newPos, delta.lines); + } + } else if (delta.action === 'remove') { + for (var i = this.others.length - 1; i >= 0; i--) { + var otherPos = this.others[i]; + var newPos = {row: otherPos.row, column: otherPos.column + distanceFromStart}; + this.doc.remove(new Range(newPos.row, newPos.column, newPos.row, newPos.column - lengthDiff)); + } + } + } + + this.$updating = false; + this.updateMarkers(); + }; + + this.updateAnchors = function(delta) { + this.pos.onChange(delta); + for (var i = this.others.length; i--;) + this.others[i].onChange(delta); + this.updateMarkers(); + }; + + this.updateMarkers = function() { + if (this.$updating) + return; + var _self = this; + var session = this.session; + var updateMarker = function(pos, className) { + session.removeMarker(pos.markerId); + pos.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column+_self.length), className, null, false); + }; + updateMarker(this.pos, this.mainClass); + for (var i = this.others.length; i--;) + updateMarker(this.others[i], this.othersClass); + }; + + this.onCursorChange = function(event) { + if (this.$updating || !this.session) return; + var pos = this.session.selection.getCursor(); + if (pos.row === this.pos.row && pos.column >= this.pos.column && pos.column <= this.pos.column + this.length) { + this.showOtherMarkers(); + this._emit("cursorEnter", event); + } else { + this.hideOtherMarkers(); + this._emit("cursorLeave", event); + } + }; + this.detach = function() { + this.session.removeMarker(this.pos && this.pos.markerId); + this.hideOtherMarkers(); + this.doc.off("change", this.$onUpdate); + this.session.selection.off("changeCursor", this.$onCursorChange); + this.session.setUndoSelect(true); + this.session = null; + }; + this.cancel = function() { + if (this.$undoStackDepth === -1) + return; + var undoManager = this.session.getUndoManager(); + var undosRequired = (undoManager.$undoStack || undoManager.$undostack).length - this.$undoStackDepth; + for (var i = 0; i < undosRequired; i++) { + undoManager.undo(this.session, true); + } + if (this.selectionBefore) + this.session.selection.fromJSON(this.selectionBefore); + }; +}).call(PlaceHolder.prototype); + + +exports.PlaceHolder = PlaceHolder; +}); + +ace.define("ace/mouse/multi_select_handler",["require","exports","module","ace/lib/event","ace/lib/useragent"], function(require, exports, module) { + +var event = require("../lib/event"); +var useragent = require("../lib/useragent"); +function isSamePoint(p1, p2) { + return p1.row == p2.row && p1.column == p2.column; +} + +function onMouseDown(e) { + var ev = e.domEvent; + var alt = ev.altKey; + var shift = ev.shiftKey; + var ctrl = ev.ctrlKey; + var accel = e.getAccelKey(); + var button = e.getButton(); + + if (ctrl && useragent.isMac) + button = ev.button; + + if (e.editor.inMultiSelectMode && button == 2) { + e.editor.textInput.onContextMenu(e.domEvent); + return; + } + + if (!ctrl && !alt && !accel) { + if (button === 0 && e.editor.inMultiSelectMode) + e.editor.exitMultiSelectMode(); + return; + } + + if (button !== 0) + return; + + var editor = e.editor; + var selection = editor.selection; + var isMultiSelect = editor.inMultiSelectMode; + var pos = e.getDocumentPosition(); + var cursor = selection.getCursor(); + var inSelection = e.inSelection() || (selection.isEmpty() && isSamePoint(pos, cursor)); + + var mouseX = e.x, mouseY = e.y; + var onMouseSelection = function(e) { + mouseX = e.clientX; + mouseY = e.clientY; + }; + + var session = editor.session; + var screenAnchor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY); + var screenCursor = screenAnchor; + + var selectionMode; + if (editor.$mouseHandler.$enableJumpToDef) { + if (ctrl && alt || accel && alt) + selectionMode = shift ? "block" : "add"; + else if (alt && editor.$blockSelectEnabled) + selectionMode = "block"; + } else { + if (accel && !alt) { + selectionMode = "add"; + if (!isMultiSelect && shift) + return; + } else if (alt && editor.$blockSelectEnabled) { + selectionMode = "block"; + } + } + + if (selectionMode && useragent.isMac && ev.ctrlKey) { + editor.$mouseHandler.cancelContextMenu(); + } + + if (selectionMode == "add") { + if (!isMultiSelect && inSelection) + return; // dragging + + if (!isMultiSelect) { + var range = selection.toOrientedRange(); + editor.addSelectionMarker(range); + } + + var oldRange = selection.rangeList.rangeAtPoint(pos); + + editor.inVirtualSelectionMode = true; + + if (shift) { + oldRange = null; + range = selection.ranges[0] || range; + editor.removeSelectionMarker(range); + } + editor.once("mouseup", function() { + var tmpSel = selection.toOrientedRange(); + + if (oldRange && tmpSel.isEmpty() && isSamePoint(oldRange.cursor, tmpSel.cursor)) + selection.substractPoint(tmpSel.cursor); + else { + if (shift) { + selection.substractPoint(range.cursor); + } else if (range) { + editor.removeSelectionMarker(range); + selection.addRange(range); + } + selection.addRange(tmpSel); + } + editor.inVirtualSelectionMode = false; + }); + + } else if (selectionMode == "block") { + e.stop(); + editor.inVirtualSelectionMode = true; + var initialRange; + var rectSel = []; + var blockSelect = function() { + var newCursor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY); + var cursor = session.screenToDocumentPosition(newCursor.row, newCursor.column, newCursor.offsetX); + + if (isSamePoint(screenCursor, newCursor) && isSamePoint(cursor, selection.lead)) + return; + screenCursor = newCursor; + + editor.selection.moveToPosition(cursor); + editor.renderer.scrollCursorIntoView(); + + editor.removeSelectionMarkers(rectSel); + rectSel = selection.rectangularRangeBlock(screenCursor, screenAnchor); + if (editor.$mouseHandler.$clickSelection && rectSel.length == 1 && rectSel[0].isEmpty()) + rectSel[0] = editor.$mouseHandler.$clickSelection.clone(); + rectSel.forEach(editor.addSelectionMarker, editor); + editor.updateSelectionMarkers(); + }; + if (isMultiSelect && !accel) { + selection.toSingleRange(); + } else if (!isMultiSelect && accel) { + initialRange = selection.toOrientedRange(); + editor.addSelectionMarker(initialRange); + } + + if (shift) + screenAnchor = session.documentToScreenPosition(selection.lead); + else + selection.moveToPosition(pos); + + screenCursor = {row: -1, column: -1}; + + var onMouseSelectionEnd = function(e) { + blockSelect(); + clearInterval(timerId); + editor.removeSelectionMarkers(rectSel); + if (!rectSel.length) + rectSel = [selection.toOrientedRange()]; + if (initialRange) { + editor.removeSelectionMarker(initialRange); + selection.toSingleRange(initialRange); + } + for (var i = 0; i < rectSel.length; i++) + selection.addRange(rectSel[i]); + editor.inVirtualSelectionMode = false; + editor.$mouseHandler.$clickSelection = null; + }; + + var onSelectionInterval = blockSelect; + + event.capture(editor.container, onMouseSelection, onMouseSelectionEnd); + var timerId = setInterval(function() {onSelectionInterval();}, 20); + + return e.preventDefault(); + } +} + + +exports.onMouseDown = onMouseDown; + +}); + +ace.define("ace/commands/multi_select_commands",["require","exports","module","ace/keyboard/hash_handler"], function(require, exports, module) { +exports.defaultCommands = [{ + name: "addCursorAbove", + description: "Add cursor above", + exec: function(editor) { editor.selectMoreLines(-1); }, + bindKey: {win: "Ctrl-Alt-Up", mac: "Ctrl-Alt-Up"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "addCursorBelow", + description: "Add cursor below", + exec: function(editor) { editor.selectMoreLines(1); }, + bindKey: {win: "Ctrl-Alt-Down", mac: "Ctrl-Alt-Down"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "addCursorAboveSkipCurrent", + description: "Add cursor above (skip current)", + exec: function(editor) { editor.selectMoreLines(-1, true); }, + bindKey: {win: "Ctrl-Alt-Shift-Up", mac: "Ctrl-Alt-Shift-Up"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "addCursorBelowSkipCurrent", + description: "Add cursor below (skip current)", + exec: function(editor) { editor.selectMoreLines(1, true); }, + bindKey: {win: "Ctrl-Alt-Shift-Down", mac: "Ctrl-Alt-Shift-Down"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectMoreBefore", + description: "Select more before", + exec: function(editor) { editor.selectMore(-1); }, + bindKey: {win: "Ctrl-Alt-Left", mac: "Ctrl-Alt-Left"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectMoreAfter", + description: "Select more after", + exec: function(editor) { editor.selectMore(1); }, + bindKey: {win: "Ctrl-Alt-Right", mac: "Ctrl-Alt-Right"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectNextBefore", + description: "Select next before", + exec: function(editor) { editor.selectMore(-1, true); }, + bindKey: {win: "Ctrl-Alt-Shift-Left", mac: "Ctrl-Alt-Shift-Left"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "selectNextAfter", + description: "Select next after", + exec: function(editor) { editor.selectMore(1, true); }, + bindKey: {win: "Ctrl-Alt-Shift-Right", mac: "Ctrl-Alt-Shift-Right"}, + scrollIntoView: "cursor", + readOnly: true +}, { + name: "toggleSplitSelectionIntoLines", + description: "Split into lines", + exec: function(editor) { + if (editor.multiSelect.rangeCount > 1) + editor.multiSelect.joinSelections(); + else + editor.multiSelect.splitIntoLines(); + }, + bindKey: {win: "Ctrl-Alt-L", mac: "Ctrl-Alt-L"}, + readOnly: true +}, { + name: "splitSelectionIntoLines", + description: "Split into lines", + exec: function(editor) { editor.multiSelect.splitIntoLines(); }, + readOnly: true +}, { + name: "alignCursors", + description: "Align cursors", + exec: function(editor) { editor.alignCursors(); }, + bindKey: {win: "Ctrl-Alt-A", mac: "Ctrl-Alt-A"}, + scrollIntoView: "cursor" +}, { + name: "findAll", + description: "Find all", + exec: function(editor) { editor.findAll(); }, + bindKey: {win: "Ctrl-Alt-K", mac: "Ctrl-Alt-G"}, + scrollIntoView: "cursor", + readOnly: true +}]; +exports.multiSelectCommands = [{ + name: "singleSelection", + description: "Single selection", + bindKey: "esc", + exec: function(editor) { editor.exitMultiSelectMode(); }, + scrollIntoView: "cursor", + readOnly: true, + isAvailable: function(editor) {return editor && editor.inMultiSelectMode;} +}]; + +var HashHandler = require("../keyboard/hash_handler").HashHandler; +exports.keyboardHandler = new HashHandler(exports.multiSelectCommands); + +}); + +ace.define("ace/multi_select",["require","exports","module","ace/range_list","ace/range","ace/selection","ace/mouse/multi_select_handler","ace/lib/event","ace/lib/lang","ace/commands/multi_select_commands","ace/search","ace/edit_session","ace/editor","ace/config"], function(require, exports, module) { + +var RangeList = require("./range_list").RangeList; +var Range = require("./range").Range; +var Selection = require("./selection").Selection; +var onMouseDown = require("./mouse/multi_select_handler").onMouseDown; +var event = require("./lib/event"); +var lang = require("./lib/lang"); +var commands = require("./commands/multi_select_commands"); +exports.commands = commands.defaultCommands.concat(commands.multiSelectCommands); +var Search = require("./search").Search; +var search = new Search(); + +function find(session, needle, dir) { + search.$options.wrap = true; + search.$options.needle = needle; + search.$options.backwards = dir == -1; + return search.find(session); +} +var EditSession = require("./edit_session").EditSession; +(function() { + this.getSelectionMarkers = function() { + return this.$selectionMarkers; + }; +}).call(EditSession.prototype); +(function() { + this.ranges = null; + this.rangeList = null; + this.addRange = function(range, $blockChangeEvents) { + if (!range) + return; + + if (!this.inMultiSelectMode && this.rangeCount === 0) { + var oldRange = this.toOrientedRange(); + this.rangeList.add(oldRange); + this.rangeList.add(range); + if (this.rangeList.ranges.length != 2) { + this.rangeList.removeAll(); + return $blockChangeEvents || this.fromOrientedRange(range); + } + this.rangeList.removeAll(); + this.rangeList.add(oldRange); + this.$onAddRange(oldRange); + } + + if (!range.cursor) + range.cursor = range.end; + + var removed = this.rangeList.add(range); + + this.$onAddRange(range); + + if (removed.length) + this.$onRemoveRange(removed); + + if (this.rangeCount > 1 && !this.inMultiSelectMode) { + this._signal("multiSelect"); + this.inMultiSelectMode = true; + this.session.$undoSelect = false; + this.rangeList.attach(this.session); + } + + return $blockChangeEvents || this.fromOrientedRange(range); + }; + this.toSingleRange = function(range) { + range = range || this.ranges[0]; + var removed = this.rangeList.removeAll(); + if (removed.length) + this.$onRemoveRange(removed); + + range && this.fromOrientedRange(range); + }; + this.substractPoint = function(pos) { + var removed = this.rangeList.substractPoint(pos); + if (removed) { + this.$onRemoveRange(removed); + return removed[0]; + } + }; + this.mergeOverlappingRanges = function() { + var removed = this.rangeList.merge(); + if (removed.length) + this.$onRemoveRange(removed); + }; + + this.$onAddRange = function(range) { + this.rangeCount = this.rangeList.ranges.length; + this.ranges.unshift(range); + this._signal("addRange", {range: range}); + }; + + this.$onRemoveRange = function(removed) { + this.rangeCount = this.rangeList.ranges.length; + if (this.rangeCount == 1 && this.inMultiSelectMode) { + var lastRange = this.rangeList.ranges.pop(); + removed.push(lastRange); + this.rangeCount = 0; + } + + for (var i = removed.length; i--; ) { + var index = this.ranges.indexOf(removed[i]); + this.ranges.splice(index, 1); + } + + this._signal("removeRange", {ranges: removed}); + + if (this.rangeCount === 0 && this.inMultiSelectMode) { + this.inMultiSelectMode = false; + this._signal("singleSelect"); + this.session.$undoSelect = true; + this.rangeList.detach(this.session); + } + + lastRange = lastRange || this.ranges[0]; + if (lastRange && !lastRange.isEqual(this.getRange())) + this.fromOrientedRange(lastRange); + }; + this.$initRangeList = function() { + if (this.rangeList) + return; + + this.rangeList = new RangeList(); + this.ranges = []; + this.rangeCount = 0; + }; + this.getAllRanges = function() { + return this.rangeCount ? this.rangeList.ranges.concat() : [this.getRange()]; + }; + this.splitIntoLines = function () { + var ranges = this.ranges.length ? this.ranges : [this.getRange()]; + var newRanges = []; + for (var i = 0; i < ranges.length; i++) { + var range = ranges[i]; + var row = range.start.row; + var endRow = range.end.row; + if (row === endRow) { + newRanges.push(range.clone()); + } else { + newRanges.push(new Range(row, range.start.column, row, this.session.getLine(row).length)); + while (++row < endRow) + newRanges.push(this.getLineRange(row, true)); + newRanges.push(new Range(endRow, 0, endRow, range.end.column)); + } + if (i == 0 && !this.isBackwards()) + newRanges = newRanges.reverse(); + } + this.toSingleRange(); + for (var i = newRanges.length; i--;) + this.addRange(newRanges[i]); + }; + + this.joinSelections = function () { + var ranges = this.rangeList.ranges; + var lastRange = ranges[ranges.length - 1]; + var range = Range.fromPoints(ranges[0].start, lastRange.end); + + this.toSingleRange(); + this.setSelectionRange(range, lastRange.cursor == lastRange.start); + }; + this.toggleBlockSelection = function () { + if (this.rangeCount > 1) { + var ranges = this.rangeList.ranges; + var lastRange = ranges[ranges.length - 1]; + var range = Range.fromPoints(ranges[0].start, lastRange.end); + + this.toSingleRange(); + this.setSelectionRange(range, lastRange.cursor == lastRange.start); + } else { + var cursor = this.session.documentToScreenPosition(this.cursor); + var anchor = this.session.documentToScreenPosition(this.anchor); + + var rectSel = this.rectangularRangeBlock(cursor, anchor); + rectSel.forEach(this.addRange, this); + } + }; + this.rectangularRangeBlock = function(screenCursor, screenAnchor, includeEmptyLines) { + var rectSel = []; + + var xBackwards = screenCursor.column < screenAnchor.column; + if (xBackwards) { + var startColumn = screenCursor.column; + var endColumn = screenAnchor.column; + var startOffsetX = screenCursor.offsetX; + var endOffsetX = screenAnchor.offsetX; + } else { + var startColumn = screenAnchor.column; + var endColumn = screenCursor.column; + var startOffsetX = screenAnchor.offsetX; + var endOffsetX = screenCursor.offsetX; + } + + var yBackwards = screenCursor.row < screenAnchor.row; + if (yBackwards) { + var startRow = screenCursor.row; + var endRow = screenAnchor.row; + } else { + var startRow = screenAnchor.row; + var endRow = screenCursor.row; + } + + if (startColumn < 0) + startColumn = 0; + if (startRow < 0) + startRow = 0; + + if (startRow == endRow) + includeEmptyLines = true; + + var docEnd; + for (var row = startRow; row <= endRow; row++) { + var range = Range.fromPoints( + this.session.screenToDocumentPosition(row, startColumn, startOffsetX), + this.session.screenToDocumentPosition(row, endColumn, endOffsetX) + ); + if (range.isEmpty()) { + if (docEnd && isSamePoint(range.end, docEnd)) + break; + docEnd = range.end; + } + range.cursor = xBackwards ? range.start : range.end; + rectSel.push(range); + } + + if (yBackwards) + rectSel.reverse(); + + if (!includeEmptyLines) { + var end = rectSel.length - 1; + while (rectSel[end].isEmpty() && end > 0) + end--; + if (end > 0) { + var start = 0; + while (rectSel[start].isEmpty()) + start++; + } + for (var i = end; i >= start; i--) { + if (rectSel[i].isEmpty()) + rectSel.splice(i, 1); + } + } + + return rectSel; + }; +}).call(Selection.prototype); +var Editor = require("./editor").Editor; +(function() { + this.updateSelectionMarkers = function() { + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + }; + this.addSelectionMarker = function(orientedRange) { + if (!orientedRange.cursor) + orientedRange.cursor = orientedRange.end; + + var style = this.getSelectionStyle(); + orientedRange.marker = this.session.addMarker(orientedRange, "ace_selection", style); + + this.session.$selectionMarkers.push(orientedRange); + this.session.selectionMarkerCount = this.session.$selectionMarkers.length; + return orientedRange; + }; + this.removeSelectionMarker = function(range) { + if (!range.marker) + return; + this.session.removeMarker(range.marker); + var index = this.session.$selectionMarkers.indexOf(range); + if (index != -1) + this.session.$selectionMarkers.splice(index, 1); + this.session.selectionMarkerCount = this.session.$selectionMarkers.length; + }; + + this.removeSelectionMarkers = function(ranges) { + var markerList = this.session.$selectionMarkers; + for (var i = ranges.length; i--; ) { + var range = ranges[i]; + if (!range.marker) + continue; + this.session.removeMarker(range.marker); + var index = markerList.indexOf(range); + if (index != -1) + markerList.splice(index, 1); + } + this.session.selectionMarkerCount = markerList.length; + }; + + this.$onAddRange = function(e) { + this.addSelectionMarker(e.range); + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + }; + + this.$onRemoveRange = function(e) { + this.removeSelectionMarkers(e.ranges); + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + }; + + this.$onMultiSelect = function(e) { + if (this.inMultiSelectMode) + return; + this.inMultiSelectMode = true; + + this.setStyle("ace_multiselect"); + this.keyBinding.addKeyboardHandler(commands.keyboardHandler); + this.commands.setDefaultHandler("exec", this.$onMultiSelectExec); + + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + }; + + this.$onSingleSelect = function(e) { + if (this.session.multiSelect.inVirtualMode) + return; + this.inMultiSelectMode = false; + + this.unsetStyle("ace_multiselect"); + this.keyBinding.removeKeyboardHandler(commands.keyboardHandler); + + this.commands.removeDefaultHandler("exec", this.$onMultiSelectExec); + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + this._emit("changeSelection"); + }; + + this.$onMultiSelectExec = function(e) { + var command = e.command; + var editor = e.editor; + if (!editor.multiSelect) + return; + if (!command.multiSelectAction) { + var result = command.exec(editor, e.args || {}); + editor.multiSelect.addRange(editor.multiSelect.toOrientedRange()); + editor.multiSelect.mergeOverlappingRanges(); + } else if (command.multiSelectAction == "forEach") { + result = editor.forEachSelection(command, e.args); + } else if (command.multiSelectAction == "forEachLine") { + result = editor.forEachSelection(command, e.args, true); + } else if (command.multiSelectAction == "single") { + editor.exitMultiSelectMode(); + result = command.exec(editor, e.args || {}); + } else { + result = command.multiSelectAction(editor, e.args || {}); + } + return result; + }; + this.forEachSelection = function(cmd, args, options) { + if (this.inVirtualSelectionMode) + return; + var keepOrder = options && options.keepOrder; + var $byLines = options == true || options && options.$byLines; + var session = this.session; + var selection = this.selection; + var rangeList = selection.rangeList; + var ranges = (keepOrder ? selection : rangeList).ranges; + var result; + + if (!ranges.length) + return cmd.exec ? cmd.exec(this, args || {}) : cmd(this, args || {}); + + var reg = selection._eventRegistry; + selection._eventRegistry = {}; + + var tmpSel = new Selection(session); + this.inVirtualSelectionMode = true; + for (var i = ranges.length; i--;) { + if ($byLines) { + while (i > 0 && ranges[i].start.row == ranges[i - 1].end.row) + i--; + } + tmpSel.fromOrientedRange(ranges[i]); + tmpSel.index = i; + this.selection = session.selection = tmpSel; + var cmdResult = cmd.exec ? cmd.exec(this, args || {}) : cmd(this, args || {}); + if (!result && cmdResult !== undefined) + result = cmdResult; + tmpSel.toOrientedRange(ranges[i]); + } + tmpSel.detach(); + + this.selection = session.selection = selection; + this.inVirtualSelectionMode = false; + selection._eventRegistry = reg; + selection.mergeOverlappingRanges(); + if (selection.ranges[0]) + selection.fromOrientedRange(selection.ranges[0]); + + var anim = this.renderer.$scrollAnimation; + this.onCursorChange(); + this.onSelectionChange(); + if (anim && anim.from == anim.to) + this.renderer.animateScrolling(anim.from); + + return result; + }; + this.exitMultiSelectMode = function() { + if (!this.inMultiSelectMode || this.inVirtualSelectionMode) + return; + this.multiSelect.toSingleRange(); + }; + + this.getSelectedText = function() { + var text = ""; + if (this.inMultiSelectMode && !this.inVirtualSelectionMode) { + var ranges = this.multiSelect.rangeList.ranges; + var buf = []; + for (var i = 0; i < ranges.length; i++) { + buf.push(this.session.getTextRange(ranges[i])); + } + var nl = this.session.getDocument().getNewLineCharacter(); + text = buf.join(nl); + if (text.length == (buf.length - 1) * nl.length) + text = ""; + } else if (!this.selection.isEmpty()) { + text = this.session.getTextRange(this.getSelectionRange()); + } + return text; + }; + + this.$checkMultiselectChange = function(e, anchor) { + if (this.inMultiSelectMode && !this.inVirtualSelectionMode) { + var range = this.multiSelect.ranges[0]; + if (this.multiSelect.isEmpty() && anchor == this.multiSelect.anchor) + return; + var pos = anchor == this.multiSelect.anchor + ? range.cursor == range.start ? range.end : range.start + : range.cursor; + if (pos.row != anchor.row + || this.session.$clipPositionToDocument(pos.row, pos.column).column != anchor.column) + this.multiSelect.toSingleRange(this.multiSelect.toOrientedRange()); + else + this.multiSelect.mergeOverlappingRanges(); + } + }; + this.findAll = function(needle, options, additive) { + options = options || {}; + options.needle = needle || options.needle; + if (options.needle == undefined) { + var range = this.selection.isEmpty() + ? this.selection.getWordRange() + : this.selection.getRange(); + options.needle = this.session.getTextRange(range); + } + this.$search.set(options); + + var ranges = this.$search.findAll(this.session); + if (!ranges.length) + return 0; + + var selection = this.multiSelect; + + if (!additive) + selection.toSingleRange(ranges[0]); + + for (var i = ranges.length; i--; ) + selection.addRange(ranges[i], true); + if (range && selection.rangeList.rangeAtPoint(range.start)) + selection.addRange(range, true); + + return ranges.length; + }; + this.selectMoreLines = function(dir, skip) { + var range = this.selection.toOrientedRange(); + var isBackwards = range.cursor == range.end; + + var screenLead = this.session.documentToScreenPosition(range.cursor); + if (this.selection.$desiredColumn) + screenLead.column = this.selection.$desiredColumn; + + var lead = this.session.screenToDocumentPosition(screenLead.row + dir, screenLead.column); + + if (!range.isEmpty()) { + var screenAnchor = this.session.documentToScreenPosition(isBackwards ? range.end : range.start); + var anchor = this.session.screenToDocumentPosition(screenAnchor.row + dir, screenAnchor.column); + } else { + var anchor = lead; + } + + if (isBackwards) { + var newRange = Range.fromPoints(lead, anchor); + newRange.cursor = newRange.start; + } else { + var newRange = Range.fromPoints(anchor, lead); + newRange.cursor = newRange.end; + } + + newRange.desiredColumn = screenLead.column; + if (!this.selection.inMultiSelectMode) { + this.selection.addRange(range); + } else { + if (skip) + var toRemove = range.cursor; + } + + this.selection.addRange(newRange); + if (toRemove) + this.selection.substractPoint(toRemove); + }; + this.transposeSelections = function(dir) { + var session = this.session; + var sel = session.multiSelect; + var all = sel.ranges; + + for (var i = all.length; i--; ) { + var range = all[i]; + if (range.isEmpty()) { + var tmp = session.getWordRange(range.start.row, range.start.column); + range.start.row = tmp.start.row; + range.start.column = tmp.start.column; + range.end.row = tmp.end.row; + range.end.column = tmp.end.column; + } + } + sel.mergeOverlappingRanges(); + + var words = []; + for (var i = all.length; i--; ) { + var range = all[i]; + words.unshift(session.getTextRange(range)); + } + + if (dir < 0) + words.unshift(words.pop()); + else + words.push(words.shift()); + + for (var i = all.length; i--; ) { + var range = all[i]; + var tmp = range.clone(); + session.replace(range, words[i]); + range.start.row = tmp.start.row; + range.start.column = tmp.start.column; + } + sel.fromOrientedRange(sel.ranges[0]); + }; + this.selectMore = function(dir, skip, stopAtFirst) { + var session = this.session; + var sel = session.multiSelect; + + var range = sel.toOrientedRange(); + if (range.isEmpty()) { + range = session.getWordRange(range.start.row, range.start.column); + range.cursor = dir == -1 ? range.start : range.end; + this.multiSelect.addRange(range); + if (stopAtFirst) + return; + } + var needle = session.getTextRange(range); + + var newRange = find(session, needle, dir); + if (newRange) { + newRange.cursor = dir == -1 ? newRange.start : newRange.end; + this.session.unfold(newRange); + this.multiSelect.addRange(newRange); + this.renderer.scrollCursorIntoView(null, 0.5); + } + if (skip) + this.multiSelect.substractPoint(range.cursor); + }; + this.alignCursors = function() { + var session = this.session; + var sel = session.multiSelect; + var ranges = sel.ranges; + var row = -1; + var sameRowRanges = ranges.filter(function(r) { + if (r.cursor.row == row) + return true; + row = r.cursor.row; + }); + + if (!ranges.length || sameRowRanges.length == ranges.length - 1) { + var range = this.selection.getRange(); + var fr = range.start.row, lr = range.end.row; + var guessRange = fr == lr; + if (guessRange) { + var max = this.session.getLength(); + var line; + do { + line = this.session.getLine(lr); + } while (/[=:]/.test(line) && ++lr < max); + do { + line = this.session.getLine(fr); + } while (/[=:]/.test(line) && --fr > 0); + + if (fr < 0) fr = 0; + if (lr >= max) lr = max - 1; + } + var lines = this.session.removeFullLines(fr, lr); + lines = this.$reAlignText(lines, guessRange); + this.session.insert({row: fr, column: 0}, lines.join("\n") + "\n"); + if (!guessRange) { + range.start.column = 0; + range.end.column = lines[lines.length - 1].length; + } + this.selection.setRange(range); + } else { + sameRowRanges.forEach(function(r) { + sel.substractPoint(r.cursor); + }); + + var maxCol = 0; + var minSpace = Infinity; + var spaceOffsets = ranges.map(function(r) { + var p = r.cursor; + var line = session.getLine(p.row); + var spaceOffset = line.substr(p.column).search(/\S/g); + if (spaceOffset == -1) + spaceOffset = 0; + + if (p.column > maxCol) + maxCol = p.column; + if (spaceOffset < minSpace) + minSpace = spaceOffset; + return spaceOffset; + }); + ranges.forEach(function(r, i) { + var p = r.cursor; + var l = maxCol - p.column; + var d = spaceOffsets[i] - minSpace; + if (l > d) + session.insert(p, lang.stringRepeat(" ", l - d)); + else + session.remove(new Range(p.row, p.column, p.row, p.column - l + d)); + + r.start.column = r.end.column = maxCol; + r.start.row = r.end.row = p.row; + r.cursor = r.end; + }); + sel.fromOrientedRange(ranges[0]); + this.renderer.updateCursor(); + this.renderer.updateBackMarkers(); + } + }; + + this.$reAlignText = function(lines, forceLeft) { + var isLeftAligned = true, isRightAligned = true; + var startW, textW, endW; + + return lines.map(function(line) { + var m = line.match(/(\s*)(.*?)(\s*)([=:].*)/); + if (!m) + return [line]; + + if (startW == null) { + startW = m[1].length; + textW = m[2].length; + endW = m[3].length; + return m; + } + + if (startW + textW + endW != m[1].length + m[2].length + m[3].length) + isRightAligned = false; + if (startW != m[1].length) + isLeftAligned = false; + + if (startW > m[1].length) + startW = m[1].length; + if (textW < m[2].length) + textW = m[2].length; + if (endW > m[3].length) + endW = m[3].length; + + return m; + }).map(forceLeft ? alignLeft : + isLeftAligned ? isRightAligned ? alignRight : alignLeft : unAlign); + + function spaces(n) { + return lang.stringRepeat(" ", n); + } + + function alignLeft(m) { + return !m[2] ? m[0] : spaces(startW) + m[2] + + spaces(textW - m[2].length + endW) + + m[4].replace(/^([=:])\s+/, "$1 "); + } + function alignRight(m) { + return !m[2] ? m[0] : spaces(startW + textW - m[2].length) + m[2] + + spaces(endW) + + m[4].replace(/^([=:])\s+/, "$1 "); + } + function unAlign(m) { + return !m[2] ? m[0] : spaces(startW) + m[2] + + spaces(endW) + + m[4].replace(/^([=:])\s+/, "$1 "); + } + }; +}).call(Editor.prototype); + + +function isSamePoint(p1, p2) { + return p1.row == p2.row && p1.column == p2.column; +} +exports.onSessionChange = function(e) { + var session = e.session; + if (session && !session.multiSelect) { + session.$selectionMarkers = []; + session.selection.$initRangeList(); + session.multiSelect = session.selection; + } + this.multiSelect = session && session.multiSelect; + + var oldSession = e.oldSession; + if (oldSession) { + oldSession.multiSelect.off("addRange", this.$onAddRange); + oldSession.multiSelect.off("removeRange", this.$onRemoveRange); + oldSession.multiSelect.off("multiSelect", this.$onMultiSelect); + oldSession.multiSelect.off("singleSelect", this.$onSingleSelect); + oldSession.multiSelect.lead.off("change", this.$checkMultiselectChange); + oldSession.multiSelect.anchor.off("change", this.$checkMultiselectChange); + } + + if (session) { + session.multiSelect.on("addRange", this.$onAddRange); + session.multiSelect.on("removeRange", this.$onRemoveRange); + session.multiSelect.on("multiSelect", this.$onMultiSelect); + session.multiSelect.on("singleSelect", this.$onSingleSelect); + session.multiSelect.lead.on("change", this.$checkMultiselectChange); + session.multiSelect.anchor.on("change", this.$checkMultiselectChange); + } + + if (session && this.inMultiSelectMode != session.selection.inMultiSelectMode) { + if (session.selection.inMultiSelectMode) + this.$onMultiSelect(); + else + this.$onSingleSelect(); + } +}; +function MultiSelect(editor) { + if (editor.$multiselectOnSessionChange) + return; + editor.$onAddRange = editor.$onAddRange.bind(editor); + editor.$onRemoveRange = editor.$onRemoveRange.bind(editor); + editor.$onMultiSelect = editor.$onMultiSelect.bind(editor); + editor.$onSingleSelect = editor.$onSingleSelect.bind(editor); + editor.$multiselectOnSessionChange = exports.onSessionChange.bind(editor); + editor.$checkMultiselectChange = editor.$checkMultiselectChange.bind(editor); + + editor.$multiselectOnSessionChange(editor); + editor.on("changeSession", editor.$multiselectOnSessionChange); + + editor.on("mousedown", onMouseDown); + editor.commands.addCommands(commands.defaultCommands); + + addAltCursorListeners(editor); +} + +function addAltCursorListeners(editor){ + if (!editor.textInput) return; + var el = editor.textInput.getElement(); + var altCursor = false; + event.addListener(el, "keydown", function(e) { + var altDown = e.keyCode == 18 && !(e.ctrlKey || e.shiftKey || e.metaKey); + if (editor.$blockSelectEnabled && altDown) { + if (!altCursor) { + editor.renderer.setMouseCursor("crosshair"); + altCursor = true; + } + } else if (altCursor) { + reset(); + } + }, editor); + + event.addListener(el, "keyup", reset, editor); + event.addListener(el, "blur", reset, editor); + function reset(e) { + if (altCursor) { + editor.renderer.setMouseCursor(""); + altCursor = false; + } + } +} + +exports.MultiSelect = MultiSelect; + + +require("./config").defineOptions(Editor.prototype, "editor", { + enableMultiselect: { + set: function(val) { + MultiSelect(this); + if (val) { + this.on("changeSession", this.$multiselectOnSessionChange); + this.on("mousedown", onMouseDown); + } else { + this.off("changeSession", this.$multiselectOnSessionChange); + this.off("mousedown", onMouseDown); + } + }, + value: true + }, + enableBlockSelect: { + set: function(val) { + this.$blockSelectEnabled = val; + }, + value: true + } +}); + + + +}); + +ace.define("ace/mode/folding/fold_mode",["require","exports","module","ace/range"], function(require, exports, module) { +"use strict"; + +var Range = require("../../range").Range; + +var FoldMode = exports.FoldMode = function() {}; + +(function() { + + this.foldingStartMarker = null; + this.foldingStopMarker = null; + this.getFoldWidget = function(session, foldStyle, row) { + var line = session.getLine(row); + if (this.foldingStartMarker.test(line)) + return "start"; + if (foldStyle == "markbeginend" + && this.foldingStopMarker + && this.foldingStopMarker.test(line)) + return "end"; + return ""; + }; + + this.getFoldWidgetRange = function(session, foldStyle, row) { + return null; + }; + + this.indentationBlock = function(session, row, column) { + var re = /\S/; + var line = session.getLine(row); + var startLevel = line.search(re); + if (startLevel == -1) + return; + + var startColumn = column || line.length; + var maxRow = session.getLength(); + var startRow = row; + var endRow = row; + + while (++row < maxRow) { + var level = session.getLine(row).search(re); + + if (level == -1) + continue; + + if (level <= startLevel) { + var token = session.getTokenAt(row, 0); + if (!token || token.type !== "string") + break; + } + + endRow = row; + } + + if (endRow > startRow) { + var endColumn = session.getLine(endRow).length; + return new Range(startRow, startColumn, endRow, endColumn); + } + }; + + this.openingBracketBlock = function(session, bracket, row, column, typeRe) { + var start = {row: row, column: column + 1}; + var end = session.$findClosingBracket(bracket, start, typeRe); + if (!end) + return; + + var fw = session.foldWidgets[end.row]; + if (fw == null) + fw = session.getFoldWidget(end.row); + + if (fw == "start" && end.row > start.row) { + end.row --; + end.column = session.getLine(end.row).length; + } + return Range.fromPoints(start, end); + }; + + this.closingBracketBlock = function(session, bracket, row, column, typeRe) { + var end = {row: row, column: column}; + var start = session.$findOpeningBracket(bracket, end); + + if (!start) + return; + + start.column++; + end.column--; + + return Range.fromPoints(start, end); + }; +}).call(FoldMode.prototype); + +}); + +ace.define("ace/theme/textmate",["require","exports","module","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +exports.isDark = false; +exports.cssClass = "ace-tm"; +exports.cssText = ".ace-tm .ace_gutter {\ +background: #f0f0f0;\ +color: #333;\ +}\ +.ace-tm .ace_print-margin {\ +width: 1px;\ +background: #e8e8e8;\ +}\ +.ace-tm .ace_fold {\ +background-color: #6B72E6;\ +}\ +.ace-tm {\ +background-color: #FFFFFF;\ +color: black;\ +}\ +.ace-tm .ace_cursor {\ +color: black;\ +}\ +.ace-tm .ace_invisible {\ +color: rgb(191, 191, 191);\ +}\ +.ace-tm .ace_storage,\ +.ace-tm .ace_keyword {\ +color: blue;\ +}\ +.ace-tm .ace_constant {\ +color: rgb(197, 6, 11);\ +}\ +.ace-tm .ace_constant.ace_buildin {\ +color: rgb(88, 72, 246);\ +}\ +.ace-tm .ace_constant.ace_language {\ +color: rgb(88, 92, 246);\ +}\ +.ace-tm .ace_constant.ace_library {\ +color: rgb(6, 150, 14);\ +}\ +.ace-tm .ace_invalid {\ +background-color: rgba(255, 0, 0, 0.1);\ +color: red;\ +}\ +.ace-tm .ace_support.ace_function {\ +color: rgb(60, 76, 114);\ +}\ +.ace-tm .ace_support.ace_constant {\ +color: rgb(6, 150, 14);\ +}\ +.ace-tm .ace_support.ace_type,\ +.ace-tm .ace_support.ace_class {\ +color: rgb(109, 121, 222);\ +}\ +.ace-tm .ace_keyword.ace_operator {\ +color: rgb(104, 118, 135);\ +}\ +.ace-tm .ace_string {\ +color: rgb(3, 106, 7);\ +}\ +.ace-tm .ace_comment {\ +color: rgb(76, 136, 107);\ +}\ +.ace-tm .ace_comment.ace_doc {\ +color: rgb(0, 102, 255);\ +}\ +.ace-tm .ace_comment.ace_doc.ace_tag {\ +color: rgb(128, 159, 191);\ +}\ +.ace-tm .ace_constant.ace_numeric {\ +color: rgb(0, 0, 205);\ +}\ +.ace-tm .ace_variable {\ +color: rgb(49, 132, 149);\ +}\ +.ace-tm .ace_xml-pe {\ +color: rgb(104, 104, 91);\ +}\ +.ace-tm .ace_entity.ace_name.ace_function {\ +color: #0000A2;\ +}\ +.ace-tm .ace_heading {\ +color: rgb(12, 7, 255);\ +}\ +.ace-tm .ace_list {\ +color:rgb(185, 6, 144);\ +}\ +.ace-tm .ace_meta.ace_tag {\ +color:rgb(0, 22, 142);\ +}\ +.ace-tm .ace_string.ace_regex {\ +color: rgb(255, 0, 0)\ +}\ +.ace-tm .ace_marker-layer .ace_selection {\ +background: rgb(181, 213, 255);\ +}\ +.ace-tm.ace_multiselect .ace_selection.ace_start {\ +box-shadow: 0 0 3px 0px white;\ +}\ +.ace-tm .ace_marker-layer .ace_step {\ +background: rgb(252, 255, 0);\ +}\ +.ace-tm .ace_marker-layer .ace_stack {\ +background: rgb(164, 229, 101);\ +}\ +.ace-tm .ace_marker-layer .ace_bracket {\ +margin: -1px 0 0 -1px;\ +border: 1px solid rgb(192, 192, 192);\ +}\ +.ace-tm .ace_marker-layer .ace_active-line {\ +background: rgba(0, 0, 0, 0.07);\ +}\ +.ace-tm .ace_gutter-active-line {\ +background-color : #dcdcdc;\ +}\ +.ace-tm .ace_marker-layer .ace_selected-word {\ +background: rgb(250, 250, 255);\ +border: 1px solid rgb(200, 200, 250);\ +}\ +.ace-tm .ace_indent-guide {\ +background: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==\") right repeat-y;\ +}\ +"; +exports.$id = "ace/theme/textmate"; + +var dom = require("../lib/dom"); +dom.importCssString(exports.cssText, exports.cssClass, false); +}); + +ace.define("ace/line_widgets",["require","exports","module","ace/lib/dom"], function(require, exports, module) { +"use strict"; + +var dom = require("./lib/dom"); + +function LineWidgets(session) { + this.session = session; + this.session.widgetManager = this; + this.session.getRowLength = this.getRowLength; + this.session.$getWidgetScreenLength = this.$getWidgetScreenLength; + this.updateOnChange = this.updateOnChange.bind(this); + this.renderWidgets = this.renderWidgets.bind(this); + this.measureWidgets = this.measureWidgets.bind(this); + this.session._changedWidgets = []; + this.$onChangeEditor = this.$onChangeEditor.bind(this); + + this.session.on("change", this.updateOnChange); + this.session.on("changeFold", this.updateOnFold); + this.session.on("changeEditor", this.$onChangeEditor); +} + +(function() { + this.getRowLength = function(row) { + var h; + if (this.lineWidgets) + h = this.lineWidgets[row] && this.lineWidgets[row].rowCount || 0; + else + h = 0; + if (!this.$useWrapMode || !this.$wrapData[row]) { + return 1 + h; + } else { + return this.$wrapData[row].length + 1 + h; + } + }; + + this.$getWidgetScreenLength = function() { + var screenRows = 0; + this.lineWidgets.forEach(function(w){ + if (w && w.rowCount && !w.hidden) + screenRows += w.rowCount; + }); + return screenRows; + }; + + this.$onChangeEditor = function(e) { + this.attach(e.editor); + }; + + this.attach = function(editor) { + if (editor && editor.widgetManager && editor.widgetManager != this) + editor.widgetManager.detach(); + + if (this.editor == editor) + return; + + this.detach(); + this.editor = editor; + + if (editor) { + editor.widgetManager = this; + editor.renderer.on("beforeRender", this.measureWidgets); + editor.renderer.on("afterRender", this.renderWidgets); + } + }; + this.detach = function(e) { + var editor = this.editor; + if (!editor) + return; + + this.editor = null; + editor.widgetManager = null; + + editor.renderer.off("beforeRender", this.measureWidgets); + editor.renderer.off("afterRender", this.renderWidgets); + var lineWidgets = this.session.lineWidgets; + lineWidgets && lineWidgets.forEach(function(w) { + if (w && w.el && w.el.parentNode) { + w._inDocument = false; + w.el.parentNode.removeChild(w.el); + } + }); + }; + + this.updateOnFold = function(e, session) { + var lineWidgets = session.lineWidgets; + if (!lineWidgets || !e.action) + return; + var fold = e.data; + var start = fold.start.row; + var end = fold.end.row; + var hide = e.action == "add"; + for (var i = start + 1; i < end; i++) { + if (lineWidgets[i]) + lineWidgets[i].hidden = hide; + } + if (lineWidgets[end]) { + if (hide) { + if (!lineWidgets[start]) + lineWidgets[start] = lineWidgets[end]; + else + lineWidgets[end].hidden = hide; + } else { + if (lineWidgets[start] == lineWidgets[end]) + lineWidgets[start] = undefined; + lineWidgets[end].hidden = hide; + } + } + }; + + this.updateOnChange = function(delta) { + var lineWidgets = this.session.lineWidgets; + if (!lineWidgets) return; + + var startRow = delta.start.row; + var len = delta.end.row - startRow; + + if (len === 0) { + } else if (delta.action == "remove") { + var removed = lineWidgets.splice(startRow + 1, len); + if (!lineWidgets[startRow] && removed[removed.length - 1]) { + lineWidgets[startRow] = removed.pop(); + } + removed.forEach(function(w) { + w && this.removeLineWidget(w); + }, this); + this.$updateRows(); + } else { + var args = new Array(len); + if (lineWidgets[startRow] && lineWidgets[startRow].column != null) { + if (delta.start.column > lineWidgets[startRow].column) + startRow++; + } + args.unshift(startRow, 0); + lineWidgets.splice.apply(lineWidgets, args); + this.$updateRows(); + } + }; + + this.$updateRows = function() { + var lineWidgets = this.session.lineWidgets; + if (!lineWidgets) return; + var noWidgets = true; + lineWidgets.forEach(function(w, i) { + if (w) { + noWidgets = false; + w.row = i; + while (w.$oldWidget) { + w.$oldWidget.row = i; + w = w.$oldWidget; + } + } + }); + if (noWidgets) + this.session.lineWidgets = null; + }; + + this.$registerLineWidget = function(w) { + if (!this.session.lineWidgets) + this.session.lineWidgets = new Array(this.session.getLength()); + + var old = this.session.lineWidgets[w.row]; + if (old) { + w.$oldWidget = old; + if (old.el && old.el.parentNode) { + old.el.parentNode.removeChild(old.el); + old._inDocument = false; + } + } + + this.session.lineWidgets[w.row] = w; + return w; + }; + + this.addLineWidget = function(w) { + this.$registerLineWidget(w); + w.session = this.session; + + if (!this.editor) return w; + + var renderer = this.editor.renderer; + if (w.html && !w.el) { + w.el = dom.createElement("div"); + w.el.innerHTML = w.html; + } + if (w.el) { + dom.addCssClass(w.el, "ace_lineWidgetContainer"); + w.el.style.position = "absolute"; + w.el.style.zIndex = 5; + renderer.container.appendChild(w.el); + w._inDocument = true; + + if (!w.coverGutter) { + w.el.style.zIndex = 3; + } + if (w.pixelHeight == null) { + w.pixelHeight = w.el.offsetHeight; + } + } + if (w.rowCount == null) { + w.rowCount = w.pixelHeight / renderer.layerConfig.lineHeight; + } + + var fold = this.session.getFoldAt(w.row, 0); + w.$fold = fold; + if (fold) { + var lineWidgets = this.session.lineWidgets; + if (w.row == fold.end.row && !lineWidgets[fold.start.row]) + lineWidgets[fold.start.row] = w; + else + w.hidden = true; + } + + this.session._emit("changeFold", {data:{start:{row: w.row}}}); + + this.$updateRows(); + this.renderWidgets(null, renderer); + this.onWidgetChanged(w); + return w; + }; + + this.removeLineWidget = function(w) { + w._inDocument = false; + w.session = null; + if (w.el && w.el.parentNode) + w.el.parentNode.removeChild(w.el); + if (w.editor && w.editor.destroy) try { + w.editor.destroy(); + } catch(e){} + if (this.session.lineWidgets) { + var w1 = this.session.lineWidgets[w.row]; + if (w1 == w) { + this.session.lineWidgets[w.row] = w.$oldWidget; + if (w.$oldWidget) + this.onWidgetChanged(w.$oldWidget); + } else { + while (w1) { + if (w1.$oldWidget == w) { + w1.$oldWidget = w.$oldWidget; + break; + } + w1 = w1.$oldWidget; + } + } + } + this.session._emit("changeFold", {data:{start:{row: w.row}}}); + this.$updateRows(); + }; + + this.getWidgetsAtRow = function(row) { + var lineWidgets = this.session.lineWidgets; + var w = lineWidgets && lineWidgets[row]; + var list = []; + while (w) { + list.push(w); + w = w.$oldWidget; + } + return list; + }; + + this.onWidgetChanged = function(w) { + this.session._changedWidgets.push(w); + this.editor && this.editor.renderer.updateFull(); + }; + + this.measureWidgets = function(e, renderer) { + var changedWidgets = this.session._changedWidgets; + var config = renderer.layerConfig; + + if (!changedWidgets || !changedWidgets.length) return; + var min = Infinity; + for (var i = 0; i < changedWidgets.length; i++) { + var w = changedWidgets[i]; + if (!w || !w.el) continue; + if (w.session != this.session) continue; + if (!w._inDocument) { + if (this.session.lineWidgets[w.row] != w) + continue; + w._inDocument = true; + renderer.container.appendChild(w.el); + } + + w.h = w.el.offsetHeight; + + if (!w.fixedWidth) { + w.w = w.el.offsetWidth; + w.screenWidth = Math.ceil(w.w / config.characterWidth); + } + + var rowCount = w.h / config.lineHeight; + if (w.coverLine) { + rowCount -= this.session.getRowLineCount(w.row); + if (rowCount < 0) + rowCount = 0; + } + if (w.rowCount != rowCount) { + w.rowCount = rowCount; + if (w.row < min) + min = w.row; + } + } + if (min != Infinity) { + this.session._emit("changeFold", {data:{start:{row: min}}}); + this.session.lineWidgetWidth = null; + } + this.session._changedWidgets = []; + }; + + this.renderWidgets = function(e, renderer) { + var config = renderer.layerConfig; + var lineWidgets = this.session.lineWidgets; + if (!lineWidgets) + return; + var first = Math.min(this.firstRow, config.firstRow); + var last = Math.max(this.lastRow, config.lastRow, lineWidgets.length); + + while (first > 0 && !lineWidgets[first]) + first--; + + this.firstRow = config.firstRow; + this.lastRow = config.lastRow; + + renderer.$cursorLayer.config = config; + for (var i = first; i <= last; i++) { + var w = lineWidgets[i]; + if (!w || !w.el) continue; + if (w.hidden) { + w.el.style.top = -100 - (w.pixelHeight || 0) + "px"; + continue; + } + if (!w._inDocument) { + w._inDocument = true; + renderer.container.appendChild(w.el); + } + var top = renderer.$cursorLayer.getPixelPosition({row: i, column:0}, true).top; + if (!w.coverLine) + top += config.lineHeight * this.session.getRowLineCount(w.row); + w.el.style.top = top - config.offset + "px"; + + var left = w.coverGutter ? 0 : renderer.gutterWidth; + if (!w.fixedWidth) + left -= renderer.scrollLeft; + w.el.style.left = left + "px"; + + if (w.fullWidth && w.screenWidth) { + w.el.style.minWidth = config.width + 2 * config.padding + "px"; + } + + if (w.fixedWidth) { + w.el.style.right = renderer.scrollBar.getWidth() + "px"; + } else { + w.el.style.right = ""; + } + } + }; + +}).call(LineWidgets.prototype); + + +exports.LineWidgets = LineWidgets; + +}); + +ace.define("ace/ext/error_marker",["require","exports","module","ace/line_widgets","ace/lib/dom","ace/range"], function(require, exports, module) { +"use strict"; +var LineWidgets = require("../line_widgets").LineWidgets; +var dom = require("../lib/dom"); +var Range = require("../range").Range; + +function binarySearch(array, needle, comparator) { + var first = 0; + var last = array.length - 1; + + while (first <= last) { + var mid = (first + last) >> 1; + var c = comparator(needle, array[mid]); + if (c > 0) + first = mid + 1; + else if (c < 0) + last = mid - 1; + else + return mid; + } + return -(first + 1); +} + +function findAnnotations(session, row, dir) { + var annotations = session.getAnnotations().sort(Range.comparePoints); + if (!annotations.length) + return; + + var i = binarySearch(annotations, {row: row, column: -1}, Range.comparePoints); + if (i < 0) + i = -i - 1; + + if (i >= annotations.length) + i = dir > 0 ? 0 : annotations.length - 1; + else if (i === 0 && dir < 0) + i = annotations.length - 1; + + var annotation = annotations[i]; + if (!annotation || !dir) + return; + + if (annotation.row === row) { + do { + annotation = annotations[i += dir]; + } while (annotation && annotation.row === row); + if (!annotation) + return annotations.slice(); + } + + + var matched = []; + row = annotation.row; + do { + matched[dir < 0 ? "unshift" : "push"](annotation); + annotation = annotations[i += dir]; + } while (annotation && annotation.row == row); + return matched.length && matched; +} + +exports.showErrorMarker = function(editor, dir) { + var session = editor.session; + if (!session.widgetManager) { + session.widgetManager = new LineWidgets(session); + session.widgetManager.attach(editor); + } + + var pos = editor.getCursorPosition(); + var row = pos.row; + var oldWidget = session.widgetManager.getWidgetsAtRow(row).filter(function(w) { + return w.type == "errorMarker"; + })[0]; + if (oldWidget) { + oldWidget.destroy(); + } else { + row -= dir; + } + var annotations = findAnnotations(session, row, dir); + var gutterAnno; + if (annotations) { + var annotation = annotations[0]; + pos.column = (annotation.pos && typeof annotation.column != "number" + ? annotation.pos.sc + : annotation.column) || 0; + pos.row = annotation.row; + gutterAnno = editor.renderer.$gutterLayer.$annotations[pos.row]; + } else if (oldWidget) { + return; + } else { + gutterAnno = { + text: ["Looks good!"], + className: "ace_ok" + }; + } + editor.session.unfold(pos.row); + editor.selection.moveToPosition(pos); + + var w = { + row: pos.row, + fixedWidth: true, + coverGutter: true, + el: dom.createElement("div"), + type: "errorMarker" + }; + var el = w.el.appendChild(dom.createElement("div")); + var arrow = w.el.appendChild(dom.createElement("div")); + arrow.className = "error_widget_arrow " + gutterAnno.className; + + var left = editor.renderer.$cursorLayer + .getPixelPosition(pos).left; + arrow.style.left = left + editor.renderer.gutterWidth - 5 + "px"; + + w.el.className = "error_widget_wrapper"; + el.className = "error_widget " + gutterAnno.className; + el.innerHTML = gutterAnno.text.join("
"); + + el.appendChild(dom.createElement("div")); + + var kb = function(_, hashId, keyString) { + if (hashId === 0 && (keyString === "esc" || keyString === "return")) { + w.destroy(); + return {command: "null"}; + } + }; + + w.destroy = function() { + if (editor.$mouseHandler.isMousePressed) + return; + editor.keyBinding.removeKeyboardHandler(kb); + session.widgetManager.removeLineWidget(w); + editor.off("changeSelection", w.destroy); + editor.off("changeSession", w.destroy); + editor.off("mouseup", w.destroy); + editor.off("change", w.destroy); + }; + + editor.keyBinding.addKeyboardHandler(kb); + editor.on("changeSelection", w.destroy); + editor.on("changeSession", w.destroy); + editor.on("mouseup", w.destroy); + editor.on("change", w.destroy); + + editor.session.widgetManager.addLineWidget(w); + + w.el.onmousedown = editor.focus.bind(editor); + + editor.renderer.scrollCursorIntoView(null, 0.5, {bottom: w.el.offsetHeight}); +}; + + +dom.importCssString("\ + .error_widget_wrapper {\ + background: inherit;\ + color: inherit;\ + border:none\ + }\ + .error_widget {\ + border-top: solid 2px;\ + border-bottom: solid 2px;\ + margin: 5px 0;\ + padding: 10px 40px;\ + white-space: pre-wrap;\ + }\ + .error_widget.ace_error, .error_widget_arrow.ace_error{\ + border-color: #ff5a5a\ + }\ + .error_widget.ace_warning, .error_widget_arrow.ace_warning{\ + border-color: #F1D817\ + }\ + .error_widget.ace_info, .error_widget_arrow.ace_info{\ + border-color: #5a5a5a\ + }\ + .error_widget.ace_ok, .error_widget_arrow.ace_ok{\ + border-color: #5aaa5a\ + }\ + .error_widget_arrow {\ + position: absolute;\ + border: solid 5px;\ + border-top-color: transparent!important;\ + border-right-color: transparent!important;\ + border-left-color: transparent!important;\ + top: -5px;\ + }\ +", "error_marker.css", false); + +}); + +ace.define("ace/ace",["require","exports","module","ace/lib/fixoldbrowsers","ace/lib/dom","ace/lib/event","ace/range","ace/editor","ace/edit_session","ace/undomanager","ace/virtual_renderer","ace/worker/worker_client","ace/keyboard/hash_handler","ace/placeholder","ace/multi_select","ace/mode/folding/fold_mode","ace/theme/textmate","ace/ext/error_marker","ace/config"], function(require, exports, module) { +"use strict"; + +require("./lib/fixoldbrowsers"); + +var dom = require("./lib/dom"); +var event = require("./lib/event"); + +var Range = require("./range").Range; +var Editor = require("./editor").Editor; +var EditSession = require("./edit_session").EditSession; +var UndoManager = require("./undomanager").UndoManager; +var Renderer = require("./virtual_renderer").VirtualRenderer; +require("./worker/worker_client"); +require("./keyboard/hash_handler"); +require("./placeholder"); +require("./multi_select"); +require("./mode/folding/fold_mode"); +require("./theme/textmate"); +require("./ext/error_marker"); + +exports.config = require("./config"); +exports.require = require; + +if (true) + exports.define = __webpack_require__.amdD; +exports.edit = function(el, options) { + if (typeof el == "string") { + var _id = el; + el = document.getElementById(_id); + if (!el) + throw new Error("ace.edit can't find div #" + _id); + } + + if (el && el.env && el.env.editor instanceof Editor) + return el.env.editor; + + var value = ""; + if (el && /input|textarea/i.test(el.tagName)) { + var oldNode = el; + value = oldNode.value; + el = dom.createElement("pre"); + oldNode.parentNode.replaceChild(el, oldNode); + } else if (el) { + value = el.textContent; + el.innerHTML = ""; + } + + var doc = exports.createEditSession(value); + + var editor = new Editor(new Renderer(el), doc, options); + + var env = { + document: doc, + editor: editor, + onResize: editor.resize.bind(editor, null) + }; + if (oldNode) env.textarea = oldNode; + event.addListener(window, "resize", env.onResize); + editor.on("destroy", function() { + event.removeListener(window, "resize", env.onResize); + env.editor.container.env = null; // prevent memory leak on old ie + }); + editor.container.env = editor.env = env; + return editor; +}; +exports.createEditSession = function(text, mode) { + var doc = new EditSession(text, mode); + doc.setUndoManager(new UndoManager()); + return doc; +}; +exports.Range = Range; +exports.Editor = Editor; +exports.EditSession = EditSession; +exports.UndoManager = UndoManager; +exports.VirtualRenderer = Renderer; +exports.version = exports.config.version; +}); (function() { + ace.require(["ace/ace"], function(a) { + if (a) { + a.config.init(true); + a.define = ace.define; + } + if (!window.ace) + window.ace = a; + for (var key in a) if (a.hasOwnProperty(key)) + window.ace[key] = a[key]; + window.ace["default"] = window.ace; + if ( true && module) { + module.exports = window.ace; + } + }); + })(); + + +/***/ }) + +}]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js new file mode 100644 index 000000000000..2ed289e8f201 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js @@ -0,0 +1,6573 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[981],{ + +/***/ 3083: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/* module decorator */ module = __webpack_require__.nmd(module); +ace.define("ace/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"], function(require, exports, module) { +"use strict"; + +var oop = require("./lib/oop"); +var lang = require("./lib/lang"); +var EventEmitter = require("./lib/event_emitter").EventEmitter; + +var Editor = require("./editor").Editor; +var Renderer = require("./virtual_renderer").VirtualRenderer; +var EditSession = require("./edit_session").EditSession; + + +var Split = function(container, theme, splits) { + this.BELOW = 1; + this.BESIDE = 0; + + this.$container = container; + this.$theme = theme; + this.$splits = 0; + this.$editorCSS = ""; + this.$editors = []; + this.$orientation = this.BESIDE; + + this.setSplits(splits || 1); + this.$cEditor = this.$editors[0]; + + + this.on("focus", function(editor) { + this.$cEditor = editor; + }.bind(this)); +}; + +(function(){ + + oop.implement(this, EventEmitter); + + this.$createEditor = function() { + var el = document.createElement("div"); + el.className = this.$editorCSS; + el.style.cssText = "position: absolute; top:0px; bottom:0px"; + this.$container.appendChild(el); + var editor = new Editor(new Renderer(el, this.$theme)); + + editor.on("focus", function() { + this._emit("focus", editor); + }.bind(this)); + + this.$editors.push(editor); + editor.setFontSize(this.$fontSize); + return editor; + }; + + this.setSplits = function(splits) { + var editor; + if (splits < 1) { + throw "The number of splits have to be > 0!"; + } + + if (splits == this.$splits) { + return; + } else if (splits > this.$splits) { + while (this.$splits < this.$editors.length && this.$splits < splits) { + editor = this.$editors[this.$splits]; + this.$container.appendChild(editor.container); + editor.setFontSize(this.$fontSize); + this.$splits ++; + } + while (this.$splits < splits) { + this.$createEditor(); + this.$splits ++; + } + } else { + while (this.$splits > splits) { + editor = this.$editors[this.$splits - 1]; + this.$container.removeChild(editor.container); + this.$splits --; + } + } + this.resize(); + }; + this.getSplits = function() { + return this.$splits; + }; + this.getEditor = function(idx) { + return this.$editors[idx]; + }; + this.getCurrentEditor = function() { + return this.$cEditor; + }; + this.focus = function() { + this.$cEditor.focus(); + }; + this.blur = function() { + this.$cEditor.blur(); + }; + this.setTheme = function(theme) { + this.$editors.forEach(function(editor) { + editor.setTheme(theme); + }); + }; + this.setKeyboardHandler = function(keybinding) { + this.$editors.forEach(function(editor) { + editor.setKeyboardHandler(keybinding); + }); + }; + this.forEach = function(callback, scope) { + this.$editors.forEach(callback, scope); + }; + + + this.$fontSize = ""; + this.setFontSize = function(size) { + this.$fontSize = size; + this.forEach(function(editor) { + editor.setFontSize(size); + }); + }; + + this.$cloneSession = function(session) { + var s = new EditSession(session.getDocument(), session.getMode()); + + var undoManager = session.getUndoManager(); + s.setUndoManager(undoManager); + s.setTabSize(session.getTabSize()); + s.setUseSoftTabs(session.getUseSoftTabs()); + s.setOverwrite(session.getOverwrite()); + s.setBreakpoints(session.getBreakpoints()); + s.setUseWrapMode(session.getUseWrapMode()); + s.setUseWorker(session.getUseWorker()); + s.setWrapLimitRange(session.$wrapLimitRange.min, + session.$wrapLimitRange.max); + s.$foldData = session.$cloneFoldData(); + + return s; + }; + this.setSession = function(session, idx) { + var editor; + if (idx == null) { + editor = this.$cEditor; + } else { + editor = this.$editors[idx]; + } + var isUsed = this.$editors.some(function(editor) { + return editor.session === session; + }); + + if (isUsed) { + session = this.$cloneSession(session); + } + editor.setSession(session); + return session; + }; + this.getOrientation = function() { + return this.$orientation; + }; + this.setOrientation = function(orientation) { + if (this.$orientation == orientation) { + return; + } + this.$orientation = orientation; + this.resize(); + }; + this.resize = function() { + var width = this.$container.clientWidth; + var height = this.$container.clientHeight; + var editor; + + if (this.$orientation == this.BESIDE) { + var editorWidth = width / this.$splits; + for (var i = 0; i < this.$splits; i++) { + editor = this.$editors[i]; + editor.container.style.width = editorWidth + "px"; + editor.container.style.top = "0px"; + editor.container.style.left = i * editorWidth + "px"; + editor.container.style.height = height + "px"; + editor.resize(); + } + } else { + var editorHeight = height / this.$splits; + for (var i = 0; i < this.$splits; i++) { + editor = this.$editors[i]; + editor.container.style.width = width + "px"; + editor.container.style.top = i * editorHeight + "px"; + editor.container.style.left = "0px"; + editor.container.style.height = editorHeight + "px"; + editor.resize(); + } + } + }; + +}).call(Split.prototype); + +exports.Split = Split; +}); + +ace.define("ace/ext/split",["require","exports","module","ace/split"], function(require, exports, module) { +"use strict"; +module.exports = require("../split"); + +}); (function() { + ace.require(["ace/ext/split"], function(m) { + if ( true && module) { + module.exports = m; + } + }); + })(); + + +/***/ }), + +/***/ 2027: +/***/ (function(module) { + +/** + * Diff Match and Patch + * Copyright 2018 The diff-match-patch Authors. + * https://github.com/google/diff-match-patch + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @fileoverview Computes the difference between two texts to create a patch. + * Applies the patch onto another text, allowing for errors. + * @author fraser@google.com (Neil Fraser) + */ + +/** + * Class containing the diff, match and patch methods. + * @constructor + */ +var diff_match_patch = function() { + + // Defaults. + // Redefine these in your program to override the defaults. + + // Number of seconds to map a diff before giving up (0 for infinity). + this.Diff_Timeout = 1.0; + // Cost of an empty edit operation in terms of edit characters. + this.Diff_EditCost = 4; + // At what point is no match declared (0.0 = perfection, 1.0 = very loose). + this.Match_Threshold = 0.5; + // How far to search for a match (0 = exact location, 1000+ = broad match). + // A match this many characters away from the expected location will add + // 1.0 to the score (0.0 is a perfect match). + this.Match_Distance = 1000; + // When deleting a large block of text (over ~64 characters), how close do + // the contents have to be to match the expected contents. (0.0 = perfection, + // 1.0 = very loose). Note that Match_Threshold controls how closely the + // end points of a delete need to match. + this.Patch_DeleteThreshold = 0.5; + // Chunk size for context length. + this.Patch_Margin = 4; + + // The number of bits in an int. + this.Match_MaxBits = 32; +}; + + +// DIFF FUNCTIONS + + +/** + * The data structure representing a diff is an array of tuples: + * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']] + * which means: delete 'Hello', add 'Goodbye' and keep ' world.' + */ +var DIFF_DELETE = -1; +var DIFF_INSERT = 1; +var DIFF_EQUAL = 0; + +/** + * Class representing one diff tuple. + * ~Attempts to look like a two-element array (which is what this used to be).~ + * Constructor returns an actual two-element array, to allow destructing @JackuB + * See https://github.com/JackuB/diff-match-patch/issues/14 for details + * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL. + * @param {string} text Text to be deleted, inserted, or retained. + * @constructor + */ +diff_match_patch.Diff = function(op, text) { + return [op, text]; +}; + +/** + * Find the differences between two texts. Simplifies the problem by stripping + * any common prefix or suffix off the texts before diffing. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {boolean=} opt_checklines Optional speedup flag. If present and false, + * then don't run a line-level diff first to identify the changed areas. + * Defaults to true, which does a faster, slightly less optimal diff. + * @param {number=} opt_deadline Optional time when the diff should be complete + * by. Used internally for recursive calls. Users should set DiffTimeout + * instead. + * @return {!Array.} Array of diff tuples. + */ +diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines, + opt_deadline) { + // Set a deadline by which time the diff must be complete. + if (typeof opt_deadline == 'undefined') { + if (this.Diff_Timeout <= 0) { + opt_deadline = Number.MAX_VALUE; + } else { + opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000; + } + } + var deadline = opt_deadline; + + // Check for null inputs. + if (text1 == null || text2 == null) { + throw new Error('Null input. (diff_main)'); + } + + // Check for equality (speedup). + if (text1 == text2) { + if (text1) { + return [new diff_match_patch.Diff(DIFF_EQUAL, text1)]; + } + return []; + } + + if (typeof opt_checklines == 'undefined') { + opt_checklines = true; + } + var checklines = opt_checklines; + + // Trim off common prefix (speedup). + var commonlength = this.diff_commonPrefix(text1, text2); + var commonprefix = text1.substring(0, commonlength); + text1 = text1.substring(commonlength); + text2 = text2.substring(commonlength); + + // Trim off common suffix (speedup). + commonlength = this.diff_commonSuffix(text1, text2); + var commonsuffix = text1.substring(text1.length - commonlength); + text1 = text1.substring(0, text1.length - commonlength); + text2 = text2.substring(0, text2.length - commonlength); + + // Compute the diff on the middle block. + var diffs = this.diff_compute_(text1, text2, checklines, deadline); + + // Restore the prefix and suffix. + if (commonprefix) { + diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix)); + } + if (commonsuffix) { + diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix)); + } + this.diff_cleanupMerge(diffs); + return diffs; +}; + + +/** + * Find the differences between two texts. Assumes that the texts do not + * have any common prefix or suffix. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {boolean} checklines Speedup flag. If false, then don't run a + * line-level diff first to identify the changed areas. + * If true, then run a faster, slightly less optimal diff. + * @param {number} deadline Time when the diff should be complete by. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines, + deadline) { + var diffs; + + if (!text1) { + // Just add some text (speedup). + return [new diff_match_patch.Diff(DIFF_INSERT, text2)]; + } + + if (!text2) { + // Just delete some text (speedup). + return [new diff_match_patch.Diff(DIFF_DELETE, text1)]; + } + + var longtext = text1.length > text2.length ? text1 : text2; + var shorttext = text1.length > text2.length ? text2 : text1; + var i = longtext.indexOf(shorttext); + if (i != -1) { + // Shorter text is inside the longer text (speedup). + diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)), + new diff_match_patch.Diff(DIFF_EQUAL, shorttext), + new diff_match_patch.Diff(DIFF_INSERT, + longtext.substring(i + shorttext.length))]; + // Swap insertions for deletions if diff is reversed. + if (text1.length > text2.length) { + diffs[0][0] = diffs[2][0] = DIFF_DELETE; + } + return diffs; + } + + if (shorttext.length == 1) { + // Single character string. + // After the previous speedup, the character can't be an equality. + return [new diff_match_patch.Diff(DIFF_DELETE, text1), + new diff_match_patch.Diff(DIFF_INSERT, text2)]; + } + + // Check to see if the problem can be split in two. + var hm = this.diff_halfMatch_(text1, text2); + if (hm) { + // A half-match was found, sort out the return data. + var text1_a = hm[0]; + var text1_b = hm[1]; + var text2_a = hm[2]; + var text2_b = hm[3]; + var mid_common = hm[4]; + // Send both pairs off for separate processing. + var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline); + var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline); + // Merge the results. + return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)], + diffs_b); + } + + if (checklines && text1.length > 100 && text2.length > 100) { + return this.diff_lineMode_(text1, text2, deadline); + } + + return this.diff_bisect_(text1, text2, deadline); +}; + + +/** + * Do a quick line-level diff on both strings, then rediff the parts for + * greater accuracy. + * This speedup can produce non-minimal diffs. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} deadline Time when the diff should be complete by. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) { + // Scan the text on a line-by-line basis first. + var a = this.diff_linesToChars_(text1, text2); + text1 = a.chars1; + text2 = a.chars2; + var linearray = a.lineArray; + + var diffs = this.diff_main(text1, text2, false, deadline); + + // Convert the diff back to original text. + this.diff_charsToLines_(diffs, linearray); + // Eliminate freak matches (e.g. blank lines) + this.diff_cleanupSemantic(diffs); + + // Rediff any replacement blocks, this time character-by-character. + // Add a dummy entry at the end. + diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, '')); + var pointer = 0; + var count_delete = 0; + var count_insert = 0; + var text_delete = ''; + var text_insert = ''; + while (pointer < diffs.length) { + switch (diffs[pointer][0]) { + case DIFF_INSERT: + count_insert++; + text_insert += diffs[pointer][1]; + break; + case DIFF_DELETE: + count_delete++; + text_delete += diffs[pointer][1]; + break; + case DIFF_EQUAL: + // Upon reaching an equality, check for prior redundancies. + if (count_delete >= 1 && count_insert >= 1) { + // Delete the offending records and add the merged ones. + diffs.splice(pointer - count_delete - count_insert, + count_delete + count_insert); + pointer = pointer - count_delete - count_insert; + var subDiff = + this.diff_main(text_delete, text_insert, false, deadline); + for (var j = subDiff.length - 1; j >= 0; j--) { + diffs.splice(pointer, 0, subDiff[j]); + } + pointer = pointer + subDiff.length; + } + count_insert = 0; + count_delete = 0; + text_delete = ''; + text_insert = ''; + break; + } + pointer++; + } + diffs.pop(); // Remove the dummy entry at the end. + + return diffs; +}; + + +/** + * Find the 'middle snake' of a diff, split the problem in two + * and return the recursively constructed diff. + * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} deadline Time at which to bail if not yet complete. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) { + // Cache the text lengths to prevent multiple calls. + var text1_length = text1.length; + var text2_length = text2.length; + var max_d = Math.ceil((text1_length + text2_length) / 2); + var v_offset = max_d; + var v_length = 2 * max_d; + var v1 = new Array(v_length); + var v2 = new Array(v_length); + // Setting all elements to -1 is faster in Chrome & Firefox than mixing + // integers and undefined. + for (var x = 0; x < v_length; x++) { + v1[x] = -1; + v2[x] = -1; + } + v1[v_offset + 1] = 0; + v2[v_offset + 1] = 0; + var delta = text1_length - text2_length; + // If the total number of characters is odd, then the front path will collide + // with the reverse path. + var front = (delta % 2 != 0); + // Offsets for start and end of k loop. + // Prevents mapping of space beyond the grid. + var k1start = 0; + var k1end = 0; + var k2start = 0; + var k2end = 0; + for (var d = 0; d < max_d; d++) { + // Bail out if deadline is reached. + if ((new Date()).getTime() > deadline) { + break; + } + + // Walk the front path one step. + for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) { + var k1_offset = v_offset + k1; + var x1; + if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) { + x1 = v1[k1_offset + 1]; + } else { + x1 = v1[k1_offset - 1] + 1; + } + var y1 = x1 - k1; + while (x1 < text1_length && y1 < text2_length && + text1.charAt(x1) == text2.charAt(y1)) { + x1++; + y1++; + } + v1[k1_offset] = x1; + if (x1 > text1_length) { + // Ran off the right of the graph. + k1end += 2; + } else if (y1 > text2_length) { + // Ran off the bottom of the graph. + k1start += 2; + } else if (front) { + var k2_offset = v_offset + delta - k1; + if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) { + // Mirror x2 onto top-left coordinate system. + var x2 = text1_length - v2[k2_offset]; + if (x1 >= x2) { + // Overlap detected. + return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); + } + } + } + } + + // Walk the reverse path one step. + for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) { + var k2_offset = v_offset + k2; + var x2; + if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) { + x2 = v2[k2_offset + 1]; + } else { + x2 = v2[k2_offset - 1] + 1; + } + var y2 = x2 - k2; + while (x2 < text1_length && y2 < text2_length && + text1.charAt(text1_length - x2 - 1) == + text2.charAt(text2_length - y2 - 1)) { + x2++; + y2++; + } + v2[k2_offset] = x2; + if (x2 > text1_length) { + // Ran off the left of the graph. + k2end += 2; + } else if (y2 > text2_length) { + // Ran off the top of the graph. + k2start += 2; + } else if (!front) { + var k1_offset = v_offset + delta - k2; + if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) { + var x1 = v1[k1_offset]; + var y1 = v_offset + x1 - k1_offset; + // Mirror x2 onto top-left coordinate system. + x2 = text1_length - x2; + if (x1 >= x2) { + // Overlap detected. + return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); + } + } + } + } + } + // Diff took too long and hit the deadline or + // number of diffs equals number of characters, no commonality at all. + return [new diff_match_patch.Diff(DIFF_DELETE, text1), + new diff_match_patch.Diff(DIFF_INSERT, text2)]; +}; + + +/** + * Given the location of the 'middle snake', split the diff in two parts + * and recurse. + * @param {string} text1 Old string to be diffed. + * @param {string} text2 New string to be diffed. + * @param {number} x Index of split point in text1. + * @param {number} y Index of split point in text2. + * @param {number} deadline Time at which to bail if not yet complete. + * @return {!Array.} Array of diff tuples. + * @private + */ +diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y, + deadline) { + var text1a = text1.substring(0, x); + var text2a = text2.substring(0, y); + var text1b = text1.substring(x); + var text2b = text2.substring(y); + + // Compute both diffs serially. + var diffs = this.diff_main(text1a, text2a, false, deadline); + var diffsb = this.diff_main(text1b, text2b, false, deadline); + + return diffs.concat(diffsb); +}; + + +/** + * Split two texts into an array of strings. Reduce the texts to a string of + * hashes where each Unicode character represents one line. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {{chars1: string, chars2: string, lineArray: !Array.}} + * An object containing the encoded text1, the encoded text2 and + * the array of unique strings. + * The zeroth element of the array of unique strings is intentionally blank. + * @private + */ +diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) { + var lineArray = []; // e.g. lineArray[4] == 'Hello\n' + var lineHash = {}; // e.g. lineHash['Hello\n'] == 4 + + // '\x00' is a valid character, but various debuggers don't like it. + // So we'll insert a junk entry to avoid generating a null character. + lineArray[0] = ''; + + /** + * Split a text into an array of strings. Reduce the texts to a string of + * hashes where each Unicode character represents one line. + * Modifies linearray and linehash through being a closure. + * @param {string} text String to encode. + * @return {string} Encoded string. + * @private + */ + function diff_linesToCharsMunge_(text) { + var chars = ''; + // Walk the text, pulling out a substring for each line. + // text.split('\n') would would temporarily double our memory footprint. + // Modifying text would create many large strings to garbage collect. + var lineStart = 0; + var lineEnd = -1; + // Keeping our own length variable is faster than looking it up. + var lineArrayLength = lineArray.length; + while (lineEnd < text.length - 1) { + lineEnd = text.indexOf('\n', lineStart); + if (lineEnd == -1) { + lineEnd = text.length - 1; + } + var line = text.substring(lineStart, lineEnd + 1); + + if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : + (lineHash[line] !== undefined)) { + chars += String.fromCharCode(lineHash[line]); + } else { + if (lineArrayLength == maxLines) { + // Bail out at 65535 because + // String.fromCharCode(65536) == String.fromCharCode(0) + line = text.substring(lineStart); + lineEnd = text.length; + } + chars += String.fromCharCode(lineArrayLength); + lineHash[line] = lineArrayLength; + lineArray[lineArrayLength++] = line; + } + lineStart = lineEnd + 1; + } + return chars; + } + // Allocate 2/3rds of the space for text1, the rest for text2. + var maxLines = 40000; + var chars1 = diff_linesToCharsMunge_(text1); + maxLines = 65535; + var chars2 = diff_linesToCharsMunge_(text2); + return {chars1: chars1, chars2: chars2, lineArray: lineArray}; +}; + + +/** + * Rehydrate the text in a diff from a string of line hashes to real lines of + * text. + * @param {!Array.} diffs Array of diff tuples. + * @param {!Array.} lineArray Array of unique strings. + * @private + */ +diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) { + for (var i = 0; i < diffs.length; i++) { + var chars = diffs[i][1]; + var text = []; + for (var j = 0; j < chars.length; j++) { + text[j] = lineArray[chars.charCodeAt(j)]; + } + diffs[i][1] = text.join(''); + } +}; + + +/** + * Determine the common prefix of two strings. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the start of each + * string. + */ +diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) { + // Quick check for common null cases. + if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) { + return 0; + } + // Binary search. + // Performance analysis: https://neil.fraser.name/news/2007/10/09/ + var pointermin = 0; + var pointermax = Math.min(text1.length, text2.length); + var pointermid = pointermax; + var pointerstart = 0; + while (pointermin < pointermid) { + if (text1.substring(pointerstart, pointermid) == + text2.substring(pointerstart, pointermid)) { + pointermin = pointermid; + pointerstart = pointermin; + } else { + pointermax = pointermid; + } + pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); + } + return pointermid; +}; + + +/** + * Determine the common suffix of two strings. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the end of each string. + */ +diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) { + // Quick check for common null cases. + if (!text1 || !text2 || + text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) { + return 0; + } + // Binary search. + // Performance analysis: https://neil.fraser.name/news/2007/10/09/ + var pointermin = 0; + var pointermax = Math.min(text1.length, text2.length); + var pointermid = pointermax; + var pointerend = 0; + while (pointermin < pointermid) { + if (text1.substring(text1.length - pointermid, text1.length - pointerend) == + text2.substring(text2.length - pointermid, text2.length - pointerend)) { + pointermin = pointermid; + pointerend = pointermin; + } else { + pointermax = pointermid; + } + pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); + } + return pointermid; +}; + + +/** + * Determine if the suffix of one string is the prefix of another. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {number} The number of characters common to the end of the first + * string and the start of the second string. + * @private + */ +diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) { + // Cache the text lengths to prevent multiple calls. + var text1_length = text1.length; + var text2_length = text2.length; + // Eliminate the null case. + if (text1_length == 0 || text2_length == 0) { + return 0; + } + // Truncate the longer string. + if (text1_length > text2_length) { + text1 = text1.substring(text1_length - text2_length); + } else if (text1_length < text2_length) { + text2 = text2.substring(0, text1_length); + } + var text_length = Math.min(text1_length, text2_length); + // Quick check for the worst case. + if (text1 == text2) { + return text_length; + } + + // Start by looking for a single character match + // and increase length until no match is found. + // Performance analysis: https://neil.fraser.name/news/2010/11/04/ + var best = 0; + var length = 1; + while (true) { + var pattern = text1.substring(text_length - length); + var found = text2.indexOf(pattern); + if (found == -1) { + return best; + } + length += found; + if (found == 0 || text1.substring(text_length - length) == + text2.substring(0, length)) { + best = length; + length++; + } + } +}; + + +/** + * Do the two texts share a substring which is at least half the length of the + * longer text? + * This speedup can produce non-minimal diffs. + * @param {string} text1 First string. + * @param {string} text2 Second string. + * @return {Array.} Five element Array, containing the prefix of + * text1, the suffix of text1, the prefix of text2, the suffix of + * text2 and the common middle. Or null if there was no match. + * @private + */ +diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) { + if (this.Diff_Timeout <= 0) { + // Don't risk returning a non-optimal diff if we have unlimited time. + return null; + } + var longtext = text1.length > text2.length ? text1 : text2; + var shorttext = text1.length > text2.length ? text2 : text1; + if (longtext.length < 4 || shorttext.length * 2 < longtext.length) { + return null; // Pointless. + } + var dmp = this; // 'this' becomes 'window' in a closure. + + /** + * Does a substring of shorttext exist within longtext such that the substring + * is at least half the length of longtext? + * Closure, but does not reference any external variables. + * @param {string} longtext Longer string. + * @param {string} shorttext Shorter string. + * @param {number} i Start index of quarter length substring within longtext. + * @return {Array.} Five element Array, containing the prefix of + * longtext, the suffix of longtext, the prefix of shorttext, the suffix + * of shorttext and the common middle. Or null if there was no match. + * @private + */ + function diff_halfMatchI_(longtext, shorttext, i) { + // Start with a 1/4 length substring at position i as a seed. + var seed = longtext.substring(i, i + Math.floor(longtext.length / 4)); + var j = -1; + var best_common = ''; + var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b; + while ((j = shorttext.indexOf(seed, j + 1)) != -1) { + var prefixLength = dmp.diff_commonPrefix(longtext.substring(i), + shorttext.substring(j)); + var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i), + shorttext.substring(0, j)); + if (best_common.length < suffixLength + prefixLength) { + best_common = shorttext.substring(j - suffixLength, j) + + shorttext.substring(j, j + prefixLength); + best_longtext_a = longtext.substring(0, i - suffixLength); + best_longtext_b = longtext.substring(i + prefixLength); + best_shorttext_a = shorttext.substring(0, j - suffixLength); + best_shorttext_b = shorttext.substring(j + prefixLength); + } + } + if (best_common.length * 2 >= longtext.length) { + return [best_longtext_a, best_longtext_b, + best_shorttext_a, best_shorttext_b, best_common]; + } else { + return null; + } + } + + // First check if the second quarter is the seed for a half-match. + var hm1 = diff_halfMatchI_(longtext, shorttext, + Math.ceil(longtext.length / 4)); + // Check again based on the third quarter. + var hm2 = diff_halfMatchI_(longtext, shorttext, + Math.ceil(longtext.length / 2)); + var hm; + if (!hm1 && !hm2) { + return null; + } else if (!hm2) { + hm = hm1; + } else if (!hm1) { + hm = hm2; + } else { + // Both matched. Select the longest. + hm = hm1[4].length > hm2[4].length ? hm1 : hm2; + } + + // A half-match was found, sort out the return data. + var text1_a, text1_b, text2_a, text2_b; + if (text1.length > text2.length) { + text1_a = hm[0]; + text1_b = hm[1]; + text2_a = hm[2]; + text2_b = hm[3]; + } else { + text2_a = hm[0]; + text2_b = hm[1]; + text1_a = hm[2]; + text1_b = hm[3]; + } + var mid_common = hm[4]; + return [text1_a, text1_b, text2_a, text2_b, mid_common]; +}; + + +/** + * Reduce the number of edits by eliminating semantically trivial equalities. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) { + var changes = false; + var equalities = []; // Stack of indices where equalities are found. + var equalitiesLength = 0; // Keeping our own length var is faster in JS. + /** @type {?string} */ + var lastEquality = null; + // Always equal to diffs[equalities[equalitiesLength - 1]][1] + var pointer = 0; // Index of current position. + // Number of characters that changed prior to the equality. + var length_insertions1 = 0; + var length_deletions1 = 0; + // Number of characters that changed after the equality. + var length_insertions2 = 0; + var length_deletions2 = 0; + while (pointer < diffs.length) { + if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. + equalities[equalitiesLength++] = pointer; + length_insertions1 = length_insertions2; + length_deletions1 = length_deletions2; + length_insertions2 = 0; + length_deletions2 = 0; + lastEquality = diffs[pointer][1]; + } else { // An insertion or deletion. + if (diffs[pointer][0] == DIFF_INSERT) { + length_insertions2 += diffs[pointer][1].length; + } else { + length_deletions2 += diffs[pointer][1].length; + } + // Eliminate an equality that is smaller or equal to the edits on both + // sides of it. + if (lastEquality && (lastEquality.length <= + Math.max(length_insertions1, length_deletions1)) && + (lastEquality.length <= Math.max(length_insertions2, + length_deletions2))) { + // Duplicate record. + diffs.splice(equalities[equalitiesLength - 1], 0, + new diff_match_patch.Diff(DIFF_DELETE, lastEquality)); + // Change second copy to insert. + diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; + // Throw away the equality we just deleted. + equalitiesLength--; + // Throw away the previous equality (it needs to be reevaluated). + equalitiesLength--; + pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1; + length_insertions1 = 0; // Reset the counters. + length_deletions1 = 0; + length_insertions2 = 0; + length_deletions2 = 0; + lastEquality = null; + changes = true; + } + } + pointer++; + } + + // Normalize the diff. + if (changes) { + this.diff_cleanupMerge(diffs); + } + this.diff_cleanupSemanticLossless(diffs); + + // Find any overlaps between deletions and insertions. + // e.g: abcxxxxxxdef + // -> abcxxxdef + // e.g: xxxabcdefxxx + // -> defxxxabc + // Only extract an overlap if it is as big as the edit ahead or behind it. + pointer = 1; + while (pointer < diffs.length) { + if (diffs[pointer - 1][0] == DIFF_DELETE && + diffs[pointer][0] == DIFF_INSERT) { + var deletion = diffs[pointer - 1][1]; + var insertion = diffs[pointer][1]; + var overlap_length1 = this.diff_commonOverlap_(deletion, insertion); + var overlap_length2 = this.diff_commonOverlap_(insertion, deletion); + if (overlap_length1 >= overlap_length2) { + if (overlap_length1 >= deletion.length / 2 || + overlap_length1 >= insertion.length / 2) { + // Overlap found. Insert an equality and trim the surrounding edits. + diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL, + insertion.substring(0, overlap_length1))); + diffs[pointer - 1][1] = + deletion.substring(0, deletion.length - overlap_length1); + diffs[pointer + 1][1] = insertion.substring(overlap_length1); + pointer++; + } + } else { + if (overlap_length2 >= deletion.length / 2 || + overlap_length2 >= insertion.length / 2) { + // Reverse overlap found. + // Insert an equality and swap and trim the surrounding edits. + diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL, + deletion.substring(0, overlap_length2))); + diffs[pointer - 1][0] = DIFF_INSERT; + diffs[pointer - 1][1] = + insertion.substring(0, insertion.length - overlap_length2); + diffs[pointer + 1][0] = DIFF_DELETE; + diffs[pointer + 1][1] = + deletion.substring(overlap_length2); + pointer++; + } + } + pointer++; + } + pointer++; + } +}; + + +/** + * Look for single edits surrounded on both sides by equalities + * which can be shifted sideways to align the edit to a word boundary. + * e.g: The cat came. -> The cat came. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) { + /** + * Given two strings, compute a score representing whether the internal + * boundary falls on logical boundaries. + * Scores range from 6 (best) to 0 (worst). + * Closure, but does not reference any external variables. + * @param {string} one First string. + * @param {string} two Second string. + * @return {number} The score. + * @private + */ + function diff_cleanupSemanticScore_(one, two) { + if (!one || !two) { + // Edges are the best. + return 6; + } + + // Each port of this function behaves slightly differently due to + // subtle differences in each language's definition of things like + // 'whitespace'. Since this function's purpose is largely cosmetic, + // the choice has been made to use each language's native features + // rather than force total conformity. + var char1 = one.charAt(one.length - 1); + var char2 = two.charAt(0); + var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_); + var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_); + var whitespace1 = nonAlphaNumeric1 && + char1.match(diff_match_patch.whitespaceRegex_); + var whitespace2 = nonAlphaNumeric2 && + char2.match(diff_match_patch.whitespaceRegex_); + var lineBreak1 = whitespace1 && + char1.match(diff_match_patch.linebreakRegex_); + var lineBreak2 = whitespace2 && + char2.match(diff_match_patch.linebreakRegex_); + var blankLine1 = lineBreak1 && + one.match(diff_match_patch.blanklineEndRegex_); + var blankLine2 = lineBreak2 && + two.match(diff_match_patch.blanklineStartRegex_); + + if (blankLine1 || blankLine2) { + // Five points for blank lines. + return 5; + } else if (lineBreak1 || lineBreak2) { + // Four points for line breaks. + return 4; + } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) { + // Three points for end of sentences. + return 3; + } else if (whitespace1 || whitespace2) { + // Two points for whitespace. + return 2; + } else if (nonAlphaNumeric1 || nonAlphaNumeric2) { + // One point for non-alphanumeric. + return 1; + } + return 0; + } + + var pointer = 1; + // Intentionally ignore the first and last element (don't need checking). + while (pointer < diffs.length - 1) { + if (diffs[pointer - 1][0] == DIFF_EQUAL && + diffs[pointer + 1][0] == DIFF_EQUAL) { + // This is a single edit surrounded by equalities. + var equality1 = diffs[pointer - 1][1]; + var edit = diffs[pointer][1]; + var equality2 = diffs[pointer + 1][1]; + + // First, shift the edit as far left as possible. + var commonOffset = this.diff_commonSuffix(equality1, edit); + if (commonOffset) { + var commonString = edit.substring(edit.length - commonOffset); + equality1 = equality1.substring(0, equality1.length - commonOffset); + edit = commonString + edit.substring(0, edit.length - commonOffset); + equality2 = commonString + equality2; + } + + // Second, step character by character right, looking for the best fit. + var bestEquality1 = equality1; + var bestEdit = edit; + var bestEquality2 = equality2; + var bestScore = diff_cleanupSemanticScore_(equality1, edit) + + diff_cleanupSemanticScore_(edit, equality2); + while (edit.charAt(0) === equality2.charAt(0)) { + equality1 += edit.charAt(0); + edit = edit.substring(1) + equality2.charAt(0); + equality2 = equality2.substring(1); + var score = diff_cleanupSemanticScore_(equality1, edit) + + diff_cleanupSemanticScore_(edit, equality2); + // The >= encourages trailing rather than leading whitespace on edits. + if (score >= bestScore) { + bestScore = score; + bestEquality1 = equality1; + bestEdit = edit; + bestEquality2 = equality2; + } + } + + if (diffs[pointer - 1][1] != bestEquality1) { + // We have an improvement, save it back to the diff. + if (bestEquality1) { + diffs[pointer - 1][1] = bestEquality1; + } else { + diffs.splice(pointer - 1, 1); + pointer--; + } + diffs[pointer][1] = bestEdit; + if (bestEquality2) { + diffs[pointer + 1][1] = bestEquality2; + } else { + diffs.splice(pointer + 1, 1); + pointer--; + } + } + } + pointer++; + } +}; + +// Define some regex patterns for matching boundaries. +diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/; +diff_match_patch.whitespaceRegex_ = /\s/; +diff_match_patch.linebreakRegex_ = /[\r\n]/; +diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/; +diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/; + +/** + * Reduce the number of edits by eliminating operationally trivial equalities. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) { + var changes = false; + var equalities = []; // Stack of indices where equalities are found. + var equalitiesLength = 0; // Keeping our own length var is faster in JS. + /** @type {?string} */ + var lastEquality = null; + // Always equal to diffs[equalities[equalitiesLength - 1]][1] + var pointer = 0; // Index of current position. + // Is there an insertion operation before the last equality. + var pre_ins = false; + // Is there a deletion operation before the last equality. + var pre_del = false; + // Is there an insertion operation after the last equality. + var post_ins = false; + // Is there a deletion operation after the last equality. + var post_del = false; + while (pointer < diffs.length) { + if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. + if (diffs[pointer][1].length < this.Diff_EditCost && + (post_ins || post_del)) { + // Candidate found. + equalities[equalitiesLength++] = pointer; + pre_ins = post_ins; + pre_del = post_del; + lastEquality = diffs[pointer][1]; + } else { + // Not a candidate, and can never become one. + equalitiesLength = 0; + lastEquality = null; + } + post_ins = post_del = false; + } else { // An insertion or deletion. + if (diffs[pointer][0] == DIFF_DELETE) { + post_del = true; + } else { + post_ins = true; + } + /* + * Five types to be split: + * ABXYCD + * AXCD + * ABXC + * AXCD + * ABXC + */ + if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) || + ((lastEquality.length < this.Diff_EditCost / 2) && + (pre_ins + pre_del + post_ins + post_del) == 3))) { + // Duplicate record. + diffs.splice(equalities[equalitiesLength - 1], 0, + new diff_match_patch.Diff(DIFF_DELETE, lastEquality)); + // Change second copy to insert. + diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; + equalitiesLength--; // Throw away the equality we just deleted; + lastEquality = null; + if (pre_ins && pre_del) { + // No changes made which could affect previous entry, keep going. + post_ins = post_del = true; + equalitiesLength = 0; + } else { + equalitiesLength--; // Throw away the previous equality. + pointer = equalitiesLength > 0 ? + equalities[equalitiesLength - 1] : -1; + post_ins = post_del = false; + } + changes = true; + } + } + pointer++; + } + + if (changes) { + this.diff_cleanupMerge(diffs); + } +}; + + +/** + * Reorder and merge like edit sections. Merge equalities. + * Any edit section can move as long as it doesn't cross an equality. + * @param {!Array.} diffs Array of diff tuples. + */ +diff_match_patch.prototype.diff_cleanupMerge = function(diffs) { + // Add a dummy entry at the end. + diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, '')); + var pointer = 0; + var count_delete = 0; + var count_insert = 0; + var text_delete = ''; + var text_insert = ''; + var commonlength; + while (pointer < diffs.length) { + switch (diffs[pointer][0]) { + case DIFF_INSERT: + count_insert++; + text_insert += diffs[pointer][1]; + pointer++; + break; + case DIFF_DELETE: + count_delete++; + text_delete += diffs[pointer][1]; + pointer++; + break; + case DIFF_EQUAL: + // Upon reaching an equality, check for prior redundancies. + if (count_delete + count_insert > 1) { + if (count_delete !== 0 && count_insert !== 0) { + // Factor out any common prefixies. + commonlength = this.diff_commonPrefix(text_insert, text_delete); + if (commonlength !== 0) { + if ((pointer - count_delete - count_insert) > 0 && + diffs[pointer - count_delete - count_insert - 1][0] == + DIFF_EQUAL) { + diffs[pointer - count_delete - count_insert - 1][1] += + text_insert.substring(0, commonlength); + } else { + diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL, + text_insert.substring(0, commonlength))); + pointer++; + } + text_insert = text_insert.substring(commonlength); + text_delete = text_delete.substring(commonlength); + } + // Factor out any common suffixies. + commonlength = this.diff_commonSuffix(text_insert, text_delete); + if (commonlength !== 0) { + diffs[pointer][1] = text_insert.substring(text_insert.length - + commonlength) + diffs[pointer][1]; + text_insert = text_insert.substring(0, text_insert.length - + commonlength); + text_delete = text_delete.substring(0, text_delete.length - + commonlength); + } + } + // Delete the offending records and add the merged ones. + pointer -= count_delete + count_insert; + diffs.splice(pointer, count_delete + count_insert); + if (text_delete.length) { + diffs.splice(pointer, 0, + new diff_match_patch.Diff(DIFF_DELETE, text_delete)); + pointer++; + } + if (text_insert.length) { + diffs.splice(pointer, 0, + new diff_match_patch.Diff(DIFF_INSERT, text_insert)); + pointer++; + } + pointer++; + } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) { + // Merge this equality with the previous one. + diffs[pointer - 1][1] += diffs[pointer][1]; + diffs.splice(pointer, 1); + } else { + pointer++; + } + count_insert = 0; + count_delete = 0; + text_delete = ''; + text_insert = ''; + break; + } + } + if (diffs[diffs.length - 1][1] === '') { + diffs.pop(); // Remove the dummy entry at the end. + } + + // Second pass: look for single edits surrounded on both sides by equalities + // which can be shifted sideways to eliminate an equality. + // e.g: ABAC -> ABAC + var changes = false; + pointer = 1; + // Intentionally ignore the first and last element (don't need checking). + while (pointer < diffs.length - 1) { + if (diffs[pointer - 1][0] == DIFF_EQUAL && + diffs[pointer + 1][0] == DIFF_EQUAL) { + // This is a single edit surrounded by equalities. + if (diffs[pointer][1].substring(diffs[pointer][1].length - + diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) { + // Shift the edit over the previous equality. + diffs[pointer][1] = diffs[pointer - 1][1] + + diffs[pointer][1].substring(0, diffs[pointer][1].length - + diffs[pointer - 1][1].length); + diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1]; + diffs.splice(pointer - 1, 1); + changes = true; + } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == + diffs[pointer + 1][1]) { + // Shift the edit over the next equality. + diffs[pointer - 1][1] += diffs[pointer + 1][1]; + diffs[pointer][1] = + diffs[pointer][1].substring(diffs[pointer + 1][1].length) + + diffs[pointer + 1][1]; + diffs.splice(pointer + 1, 1); + changes = true; + } + } + pointer++; + } + // If shifts were made, the diff needs reordering and another shift sweep. + if (changes) { + this.diff_cleanupMerge(diffs); + } +}; + + +/** + * loc is a location in text1, compute and return the equivalent location in + * text2. + * e.g. 'The cat' vs 'The big cat', 1->1, 5->8 + * @param {!Array.} diffs Array of diff tuples. + * @param {number} loc Location within text1. + * @return {number} Location within text2. + */ +diff_match_patch.prototype.diff_xIndex = function(diffs, loc) { + var chars1 = 0; + var chars2 = 0; + var last_chars1 = 0; + var last_chars2 = 0; + var x; + for (x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_INSERT) { // Equality or deletion. + chars1 += diffs[x][1].length; + } + if (diffs[x][0] !== DIFF_DELETE) { // Equality or insertion. + chars2 += diffs[x][1].length; + } + if (chars1 > loc) { // Overshot the location. + break; + } + last_chars1 = chars1; + last_chars2 = chars2; + } + // Was the location was deleted? + if (diffs.length != x && diffs[x][0] === DIFF_DELETE) { + return last_chars2; + } + // Add the remaining character length. + return last_chars2 + (loc - last_chars1); +}; + + +/** + * Convert a diff array into a pretty HTML report. + * @param {!Array.} diffs Array of diff tuples. + * @return {string} HTML representation. + */ +diff_match_patch.prototype.diff_prettyHtml = function(diffs) { + var html = []; + var pattern_amp = /&/g; + var pattern_lt = //g; + var pattern_para = /\n/g; + for (var x = 0; x < diffs.length; x++) { + var op = diffs[x][0]; // Operation (insert, delete, equal) + var data = diffs[x][1]; // Text of change. + var text = data.replace(pattern_amp, '&').replace(pattern_lt, '<') + .replace(pattern_gt, '>').replace(pattern_para, '¶
'); + switch (op) { + case DIFF_INSERT: + html[x] = '' + text + ''; + break; + case DIFF_DELETE: + html[x] = '' + text + ''; + break; + case DIFF_EQUAL: + html[x] = '' + text + ''; + break; + } + } + return html.join(''); +}; + + +/** + * Compute and return the source text (all equalities and deletions). + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Source text. + */ +diff_match_patch.prototype.diff_text1 = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_INSERT) { + text[x] = diffs[x][1]; + } + } + return text.join(''); +}; + + +/** + * Compute and return the destination text (all equalities and insertions). + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Destination text. + */ +diff_match_patch.prototype.diff_text2 = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + if (diffs[x][0] !== DIFF_DELETE) { + text[x] = diffs[x][1]; + } + } + return text.join(''); +}; + + +/** + * Compute the Levenshtein distance; the number of inserted, deleted or + * substituted characters. + * @param {!Array.} diffs Array of diff tuples. + * @return {number} Number of changes. + */ +diff_match_patch.prototype.diff_levenshtein = function(diffs) { + var levenshtein = 0; + var insertions = 0; + var deletions = 0; + for (var x = 0; x < diffs.length; x++) { + var op = diffs[x][0]; + var data = diffs[x][1]; + switch (op) { + case DIFF_INSERT: + insertions += data.length; + break; + case DIFF_DELETE: + deletions += data.length; + break; + case DIFF_EQUAL: + // A deletion and an insertion is one substitution. + levenshtein += Math.max(insertions, deletions); + insertions = 0; + deletions = 0; + break; + } + } + levenshtein += Math.max(insertions, deletions); + return levenshtein; +}; + + +/** + * Crush the diff into an encoded string which describes the operations + * required to transform text1 into text2. + * E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. + * Operations are tab-separated. Inserted text is escaped using %xx notation. + * @param {!Array.} diffs Array of diff tuples. + * @return {string} Delta text. + */ +diff_match_patch.prototype.diff_toDelta = function(diffs) { + var text = []; + for (var x = 0; x < diffs.length; x++) { + switch (diffs[x][0]) { + case DIFF_INSERT: + text[x] = '+' + encodeURI(diffs[x][1]); + break; + case DIFF_DELETE: + text[x] = '-' + diffs[x][1].length; + break; + case DIFF_EQUAL: + text[x] = '=' + diffs[x][1].length; + break; + } + } + return text.join('\t').replace(/%20/g, ' '); +}; + + +/** + * Given the original text1, and an encoded string which describes the + * operations required to transform text1 into text2, compute the full diff. + * @param {string} text1 Source string for the diff. + * @param {string} delta Delta text. + * @return {!Array.} Array of diff tuples. + * @throws {!Error} If invalid input. + */ +diff_match_patch.prototype.diff_fromDelta = function(text1, delta) { + var diffs = []; + var diffsLength = 0; // Keeping our own length var is faster in JS. + var pointer = 0; // Cursor in text1 + var tokens = delta.split(/\t/g); + for (var x = 0; x < tokens.length; x++) { + // Each token begins with a one character parameter which specifies the + // operation of this token (delete, insert, equality). + var param = tokens[x].substring(1); + switch (tokens[x].charAt(0)) { + case '+': + try { + diffs[diffsLength++] = + new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param)); + } catch (ex) { + // Malformed URI sequence. + throw new Error('Illegal escape in diff_fromDelta: ' + param); + } + break; + case '-': + // Fall through. + case '=': + var n = parseInt(param, 10); + if (isNaN(n) || n < 0) { + throw new Error('Invalid number in diff_fromDelta: ' + param); + } + var text = text1.substring(pointer, pointer += n); + if (tokens[x].charAt(0) == '=') { + diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text); + } else { + diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text); + } + break; + default: + // Blank tokens are ok (from a trailing \t). + // Anything else is an error. + if (tokens[x]) { + throw new Error('Invalid diff operation in diff_fromDelta: ' + + tokens[x]); + } + } + } + if (pointer != text1.length) { + throw new Error('Delta length (' + pointer + + ') does not equal source text length (' + text1.length + ').'); + } + return diffs; +}; + + +// MATCH FUNCTIONS + + +/** + * Locate the best instance of 'pattern' in 'text' near 'loc'. + * @param {string} text The text to search. + * @param {string} pattern The pattern to search for. + * @param {number} loc The location to search around. + * @return {number} Best match index or -1. + */ +diff_match_patch.prototype.match_main = function(text, pattern, loc) { + // Check for null inputs. + if (text == null || pattern == null || loc == null) { + throw new Error('Null input. (match_main)'); + } + + loc = Math.max(0, Math.min(loc, text.length)); + if (text == pattern) { + // Shortcut (potentially not guaranteed by the algorithm) + return 0; + } else if (!text.length) { + // Nothing to match. + return -1; + } else if (text.substring(loc, loc + pattern.length) == pattern) { + // Perfect match at the perfect spot! (Includes case of null pattern) + return loc; + } else { + // Do a fuzzy compare. + return this.match_bitap_(text, pattern, loc); + } +}; + + +/** + * Locate the best instance of 'pattern' in 'text' near 'loc' using the + * Bitap algorithm. + * @param {string} text The text to search. + * @param {string} pattern The pattern to search for. + * @param {number} loc The location to search around. + * @return {number} Best match index or -1. + * @private + */ +diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) { + if (pattern.length > this.Match_MaxBits) { + throw new Error('Pattern too long for this browser.'); + } + + // Initialise the alphabet. + var s = this.match_alphabet_(pattern); + + var dmp = this; // 'this' becomes 'window' in a closure. + + /** + * Compute and return the score for a match with e errors and x location. + * Accesses loc and pattern through being a closure. + * @param {number} e Number of errors in match. + * @param {number} x Location of match. + * @return {number} Overall score for match (0.0 = good, 1.0 = bad). + * @private + */ + function match_bitapScore_(e, x) { + var accuracy = e / pattern.length; + var proximity = Math.abs(loc - x); + if (!dmp.Match_Distance) { + // Dodge divide by zero error. + return proximity ? 1.0 : accuracy; + } + return accuracy + (proximity / dmp.Match_Distance); + } + + // Highest score beyond which we give up. + var score_threshold = this.Match_Threshold; + // Is there a nearby exact match? (speedup) + var best_loc = text.indexOf(pattern, loc); + if (best_loc != -1) { + score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold); + // What about in the other direction? (speedup) + best_loc = text.lastIndexOf(pattern, loc + pattern.length); + if (best_loc != -1) { + score_threshold = + Math.min(match_bitapScore_(0, best_loc), score_threshold); + } + } + + // Initialise the bit arrays. + var matchmask = 1 << (pattern.length - 1); + best_loc = -1; + + var bin_min, bin_mid; + var bin_max = pattern.length + text.length; + var last_rd; + for (var d = 0; d < pattern.length; d++) { + // Scan for the best match; each iteration allows for one more error. + // Run a binary search to determine how far from 'loc' we can stray at this + // error level. + bin_min = 0; + bin_mid = bin_max; + while (bin_min < bin_mid) { + if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) { + bin_min = bin_mid; + } else { + bin_max = bin_mid; + } + bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min); + } + // Use the result from this iteration as the maximum for the next. + bin_max = bin_mid; + var start = Math.max(1, loc - bin_mid + 1); + var finish = Math.min(loc + bin_mid, text.length) + pattern.length; + + var rd = Array(finish + 2); + rd[finish + 1] = (1 << d) - 1; + for (var j = finish; j >= start; j--) { + // The alphabet (s) is a sparse hash, so the following line generates + // warnings. + var charMatch = s[text.charAt(j - 1)]; + if (d === 0) { // First pass: exact match. + rd[j] = ((rd[j + 1] << 1) | 1) & charMatch; + } else { // Subsequent passes: fuzzy match. + rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | + (((last_rd[j + 1] | last_rd[j]) << 1) | 1) | + last_rd[j + 1]; + } + if (rd[j] & matchmask) { + var score = match_bitapScore_(d, j - 1); + // This match will almost certainly be better than any existing match. + // But check anyway. + if (score <= score_threshold) { + // Told you so. + score_threshold = score; + best_loc = j - 1; + if (best_loc > loc) { + // When passing loc, don't exceed our current distance from loc. + start = Math.max(1, 2 * loc - best_loc); + } else { + // Already passed loc, downhill from here on in. + break; + } + } + } + } + // No hope for a (better) match at greater error levels. + if (match_bitapScore_(d + 1, loc) > score_threshold) { + break; + } + last_rd = rd; + } + return best_loc; +}; + + +/** + * Initialise the alphabet for the Bitap algorithm. + * @param {string} pattern The text to encode. + * @return {!Object} Hash of character locations. + * @private + */ +diff_match_patch.prototype.match_alphabet_ = function(pattern) { + var s = {}; + for (var i = 0; i < pattern.length; i++) { + s[pattern.charAt(i)] = 0; + } + for (var i = 0; i < pattern.length; i++) { + s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1); + } + return s; +}; + + +// PATCH FUNCTIONS + + +/** + * Increase the context until it is unique, + * but don't let the pattern expand beyond Match_MaxBits. + * @param {!diff_match_patch.patch_obj} patch The patch to grow. + * @param {string} text Source text. + * @private + */ +diff_match_patch.prototype.patch_addContext_ = function(patch, text) { + if (text.length == 0) { + return; + } + if (patch.start2 === null) { + throw Error('patch not initialized'); + } + var pattern = text.substring(patch.start2, patch.start2 + patch.length1); + var padding = 0; + + // Look for the first and last matches of pattern in text. If two different + // matches are found, increase the pattern length. + while (text.indexOf(pattern) != text.lastIndexOf(pattern) && + pattern.length < this.Match_MaxBits - this.Patch_Margin - + this.Patch_Margin) { + padding += this.Patch_Margin; + pattern = text.substring(patch.start2 - padding, + patch.start2 + patch.length1 + padding); + } + // Add one chunk for good luck. + padding += this.Patch_Margin; + + // Add the prefix. + var prefix = text.substring(patch.start2 - padding, patch.start2); + if (prefix) { + patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix)); + } + // Add the suffix. + var suffix = text.substring(patch.start2 + patch.length1, + patch.start2 + patch.length1 + padding); + if (suffix) { + patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix)); + } + + // Roll back the start points. + patch.start1 -= prefix.length; + patch.start2 -= prefix.length; + // Extend the lengths. + patch.length1 += prefix.length + suffix.length; + patch.length2 += prefix.length + suffix.length; +}; + + +/** + * Compute a list of patches to turn text1 into text2. + * Use diffs if provided, otherwise compute it ourselves. + * There are four ways to call this function, depending on what data is + * available to the caller: + * Method 1: + * a = text1, b = text2 + * Method 2: + * a = diffs + * Method 3 (optimal): + * a = text1, b = diffs + * Method 4 (deprecated, use method 3): + * a = text1, b = text2, c = diffs + * + * @param {string|!Array.} a text1 (methods 1,3,4) or + * Array of diff tuples for text1 to text2 (method 2). + * @param {string|!Array.=} opt_b text2 (methods 1,4) or + * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2). + * @param {string|!Array.=} opt_c Array of diff tuples + * for text1 to text2 (method 4) or undefined (methods 1,2,3). + * @return {!Array.} Array of Patch objects. + */ +diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) { + var text1, diffs; + if (typeof a == 'string' && typeof opt_b == 'string' && + typeof opt_c == 'undefined') { + // Method 1: text1, text2 + // Compute diffs from text1 and text2. + text1 = /** @type {string} */(a); + diffs = this.diff_main(text1, /** @type {string} */(opt_b), true); + if (diffs.length > 2) { + this.diff_cleanupSemantic(diffs); + this.diff_cleanupEfficiency(diffs); + } + } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' && + typeof opt_c == 'undefined') { + // Method 2: diffs + // Compute text1 from diffs. + diffs = /** @type {!Array.} */(a); + text1 = this.diff_text1(diffs); + } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' && + typeof opt_c == 'undefined') { + // Method 3: text1, diffs + text1 = /** @type {string} */(a); + diffs = /** @type {!Array.} */(opt_b); + } else if (typeof a == 'string' && typeof opt_b == 'string' && + opt_c && typeof opt_c == 'object') { + // Method 4: text1, text2, diffs + // text2 is not used. + text1 = /** @type {string} */(a); + diffs = /** @type {!Array.} */(opt_c); + } else { + throw new Error('Unknown call format to patch_make.'); + } + + if (diffs.length === 0) { + return []; // Get rid of the null case. + } + var patches = []; + var patch = new diff_match_patch.patch_obj(); + var patchDiffLength = 0; // Keeping our own length var is faster in JS. + var char_count1 = 0; // Number of characters into the text1 string. + var char_count2 = 0; // Number of characters into the text2 string. + // Start with text1 (prepatch_text) and apply the diffs until we arrive at + // text2 (postpatch_text). We recreate the patches one by one to determine + // context info. + var prepatch_text = text1; + var postpatch_text = text1; + for (var x = 0; x < diffs.length; x++) { + var diff_type = diffs[x][0]; + var diff_text = diffs[x][1]; + + if (!patchDiffLength && diff_type !== DIFF_EQUAL) { + // A new patch starts here. + patch.start1 = char_count1; + patch.start2 = char_count2; + } + + switch (diff_type) { + case DIFF_INSERT: + patch.diffs[patchDiffLength++] = diffs[x]; + patch.length2 += diff_text.length; + postpatch_text = postpatch_text.substring(0, char_count2) + diff_text + + postpatch_text.substring(char_count2); + break; + case DIFF_DELETE: + patch.length1 += diff_text.length; + patch.diffs[patchDiffLength++] = diffs[x]; + postpatch_text = postpatch_text.substring(0, char_count2) + + postpatch_text.substring(char_count2 + + diff_text.length); + break; + case DIFF_EQUAL: + if (diff_text.length <= 2 * this.Patch_Margin && + patchDiffLength && diffs.length != x + 1) { + // Small equality inside a patch. + patch.diffs[patchDiffLength++] = diffs[x]; + patch.length1 += diff_text.length; + patch.length2 += diff_text.length; + } else if (diff_text.length >= 2 * this.Patch_Margin) { + // Time for a new patch. + if (patchDiffLength) { + this.patch_addContext_(patch, prepatch_text); + patches.push(patch); + patch = new diff_match_patch.patch_obj(); + patchDiffLength = 0; + // Unlike Unidiff, our patch lists have a rolling context. + // https://github.com/google/diff-match-patch/wiki/Unidiff + // Update prepatch text & pos to reflect the application of the + // just completed patch. + prepatch_text = postpatch_text; + char_count1 = char_count2; + } + } + break; + } + + // Update the current character count. + if (diff_type !== DIFF_INSERT) { + char_count1 += diff_text.length; + } + if (diff_type !== DIFF_DELETE) { + char_count2 += diff_text.length; + } + } + // Pick up the leftover patch if not empty. + if (patchDiffLength) { + this.patch_addContext_(patch, prepatch_text); + patches.push(patch); + } + + return patches; +}; + + +/** + * Given an array of patches, return another array that is identical. + * @param {!Array.} patches Array of Patch objects. + * @return {!Array.} Array of Patch objects. + */ +diff_match_patch.prototype.patch_deepCopy = function(patches) { + // Making deep copies is hard in JavaScript. + var patchesCopy = []; + for (var x = 0; x < patches.length; x++) { + var patch = patches[x]; + var patchCopy = new diff_match_patch.patch_obj(); + patchCopy.diffs = []; + for (var y = 0; y < patch.diffs.length; y++) { + patchCopy.diffs[y] = + new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]); + } + patchCopy.start1 = patch.start1; + patchCopy.start2 = patch.start2; + patchCopy.length1 = patch.length1; + patchCopy.length2 = patch.length2; + patchesCopy[x] = patchCopy; + } + return patchesCopy; +}; + + +/** + * Merge a set of patches onto the text. Return a patched text, as well + * as a list of true/false values indicating which patches were applied. + * @param {!Array.} patches Array of Patch objects. + * @param {string} text Old text. + * @return {!Array.>} Two element Array, containing the + * new text and an array of boolean values. + */ +diff_match_patch.prototype.patch_apply = function(patches, text) { + if (patches.length == 0) { + return [text, []]; + } + + // Deep copy the patches so that no changes are made to originals. + patches = this.patch_deepCopy(patches); + + var nullPadding = this.patch_addPadding(patches); + text = nullPadding + text + nullPadding; + + this.patch_splitMax(patches); + // delta keeps track of the offset between the expected and actual location + // of the previous patch. If there are patches expected at positions 10 and + // 20, but the first patch was found at 12, delta is 2 and the second patch + // has an effective expected position of 22. + var delta = 0; + var results = []; + for (var x = 0; x < patches.length; x++) { + var expected_loc = patches[x].start2 + delta; + var text1 = this.diff_text1(patches[x].diffs); + var start_loc; + var end_loc = -1; + if (text1.length > this.Match_MaxBits) { + // patch_splitMax will only provide an oversized pattern in the case of + // a monster delete. + start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits), + expected_loc); + if (start_loc != -1) { + end_loc = this.match_main(text, + text1.substring(text1.length - this.Match_MaxBits), + expected_loc + text1.length - this.Match_MaxBits); + if (end_loc == -1 || start_loc >= end_loc) { + // Can't find valid trailing context. Drop this patch. + start_loc = -1; + } + } + } else { + start_loc = this.match_main(text, text1, expected_loc); + } + if (start_loc == -1) { + // No match found. :( + results[x] = false; + // Subtract the delta for this failed patch from subsequent patches. + delta -= patches[x].length2 - patches[x].length1; + } else { + // Found a match. :) + results[x] = true; + delta = start_loc - expected_loc; + var text2; + if (end_loc == -1) { + text2 = text.substring(start_loc, start_loc + text1.length); + } else { + text2 = text.substring(start_loc, end_loc + this.Match_MaxBits); + } + if (text1 == text2) { + // Perfect match, just shove the replacement text in. + text = text.substring(0, start_loc) + + this.diff_text2(patches[x].diffs) + + text.substring(start_loc + text1.length); + } else { + // Imperfect match. Run a diff to get a framework of equivalent + // indices. + var diffs = this.diff_main(text1, text2, false); + if (text1.length > this.Match_MaxBits && + this.diff_levenshtein(diffs) / text1.length > + this.Patch_DeleteThreshold) { + // The end points match, but the content is unacceptably bad. + results[x] = false; + } else { + this.diff_cleanupSemanticLossless(diffs); + var index1 = 0; + var index2; + for (var y = 0; y < patches[x].diffs.length; y++) { + var mod = patches[x].diffs[y]; + if (mod[0] !== DIFF_EQUAL) { + index2 = this.diff_xIndex(diffs, index1); + } + if (mod[0] === DIFF_INSERT) { // Insertion + text = text.substring(0, start_loc + index2) + mod[1] + + text.substring(start_loc + index2); + } else if (mod[0] === DIFF_DELETE) { // Deletion + text = text.substring(0, start_loc + index2) + + text.substring(start_loc + this.diff_xIndex(diffs, + index1 + mod[1].length)); + } + if (mod[0] !== DIFF_DELETE) { + index1 += mod[1].length; + } + } + } + } + } + } + // Strip the padding off. + text = text.substring(nullPadding.length, text.length - nullPadding.length); + return [text, results]; +}; + + +/** + * Add some padding on text start and end so that edges can match something. + * Intended to be called only from within patch_apply. + * @param {!Array.} patches Array of Patch objects. + * @return {string} The padding string added to each side. + */ +diff_match_patch.prototype.patch_addPadding = function(patches) { + var paddingLength = this.Patch_Margin; + var nullPadding = ''; + for (var x = 1; x <= paddingLength; x++) { + nullPadding += String.fromCharCode(x); + } + + // Bump all the patches forward. + for (var x = 0; x < patches.length; x++) { + patches[x].start1 += paddingLength; + patches[x].start2 += paddingLength; + } + + // Add some padding on start of first diff. + var patch = patches[0]; + var diffs = patch.diffs; + if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) { + // Add nullPadding equality. + diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding)); + patch.start1 -= paddingLength; // Should be 0. + patch.start2 -= paddingLength; // Should be 0. + patch.length1 += paddingLength; + patch.length2 += paddingLength; + } else if (paddingLength > diffs[0][1].length) { + // Grow first equality. + var extraLength = paddingLength - diffs[0][1].length; + diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1]; + patch.start1 -= extraLength; + patch.start2 -= extraLength; + patch.length1 += extraLength; + patch.length2 += extraLength; + } + + // Add some padding on end of last diff. + patch = patches[patches.length - 1]; + diffs = patch.diffs; + if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) { + // Add nullPadding equality. + diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding)); + patch.length1 += paddingLength; + patch.length2 += paddingLength; + } else if (paddingLength > diffs[diffs.length - 1][1].length) { + // Grow last equality. + var extraLength = paddingLength - diffs[diffs.length - 1][1].length; + diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength); + patch.length1 += extraLength; + patch.length2 += extraLength; + } + + return nullPadding; +}; + + +/** + * Look through the patches and break up any which are longer than the maximum + * limit of the match algorithm. + * Intended to be called only from within patch_apply. + * @param {!Array.} patches Array of Patch objects. + */ +diff_match_patch.prototype.patch_splitMax = function(patches) { + var patch_size = this.Match_MaxBits; + for (var x = 0; x < patches.length; x++) { + if (patches[x].length1 <= patch_size) { + continue; + } + var bigpatch = patches[x]; + // Remove the big old patch. + patches.splice(x--, 1); + var start1 = bigpatch.start1; + var start2 = bigpatch.start2; + var precontext = ''; + while (bigpatch.diffs.length !== 0) { + // Create one of several smaller patches. + var patch = new diff_match_patch.patch_obj(); + var empty = true; + patch.start1 = start1 - precontext.length; + patch.start2 = start2 - precontext.length; + if (precontext !== '') { + patch.length1 = patch.length2 = precontext.length; + patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext)); + } + while (bigpatch.diffs.length !== 0 && + patch.length1 < patch_size - this.Patch_Margin) { + var diff_type = bigpatch.diffs[0][0]; + var diff_text = bigpatch.diffs[0][1]; + if (diff_type === DIFF_INSERT) { + // Insertions are harmless. + patch.length2 += diff_text.length; + start2 += diff_text.length; + patch.diffs.push(bigpatch.diffs.shift()); + empty = false; + } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 && + patch.diffs[0][0] == DIFF_EQUAL && + diff_text.length > 2 * patch_size) { + // This is a large deletion. Let it pass in one chunk. + patch.length1 += diff_text.length; + start1 += diff_text.length; + empty = false; + patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)); + bigpatch.diffs.shift(); + } else { + // Deletion or equality. Only take as much as we can stomach. + diff_text = diff_text.substring(0, + patch_size - patch.length1 - this.Patch_Margin); + patch.length1 += diff_text.length; + start1 += diff_text.length; + if (diff_type === DIFF_EQUAL) { + patch.length2 += diff_text.length; + start2 += diff_text.length; + } else { + empty = false; + } + patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)); + if (diff_text == bigpatch.diffs[0][1]) { + bigpatch.diffs.shift(); + } else { + bigpatch.diffs[0][1] = + bigpatch.diffs[0][1].substring(diff_text.length); + } + } + } + // Compute the head context for the next patch. + precontext = this.diff_text2(patch.diffs); + precontext = + precontext.substring(precontext.length - this.Patch_Margin); + // Append the end context for this patch. + var postcontext = this.diff_text1(bigpatch.diffs) + .substring(0, this.Patch_Margin); + if (postcontext !== '') { + patch.length1 += postcontext.length; + patch.length2 += postcontext.length; + if (patch.diffs.length !== 0 && + patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) { + patch.diffs[patch.diffs.length - 1][1] += postcontext; + } else { + patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext)); + } + } + if (!empty) { + patches.splice(++x, 0, patch); + } + } + } +}; + + +/** + * Take a list of patches and return a textual representation. + * @param {!Array.} patches Array of Patch objects. + * @return {string} Text representation of patches. + */ +diff_match_patch.prototype.patch_toText = function(patches) { + var text = []; + for (var x = 0; x < patches.length; x++) { + text[x] = patches[x]; + } + return text.join(''); +}; + + +/** + * Parse a textual representation of patches and return a list of Patch objects. + * @param {string} textline Text representation of patches. + * @return {!Array.} Array of Patch objects. + * @throws {!Error} If invalid input. + */ +diff_match_patch.prototype.patch_fromText = function(textline) { + var patches = []; + if (!textline) { + return patches; + } + var text = textline.split('\n'); + var textPointer = 0; + var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/; + while (textPointer < text.length) { + var m = text[textPointer].match(patchHeader); + if (!m) { + throw new Error('Invalid patch string: ' + text[textPointer]); + } + var patch = new diff_match_patch.patch_obj(); + patches.push(patch); + patch.start1 = parseInt(m[1], 10); + if (m[2] === '') { + patch.start1--; + patch.length1 = 1; + } else if (m[2] == '0') { + patch.length1 = 0; + } else { + patch.start1--; + patch.length1 = parseInt(m[2], 10); + } + + patch.start2 = parseInt(m[3], 10); + if (m[4] === '') { + patch.start2--; + patch.length2 = 1; + } else if (m[4] == '0') { + patch.length2 = 0; + } else { + patch.start2--; + patch.length2 = parseInt(m[4], 10); + } + textPointer++; + + while (textPointer < text.length) { + var sign = text[textPointer].charAt(0); + try { + var line = decodeURI(text[textPointer].substring(1)); + } catch (ex) { + // Malformed URI sequence. + throw new Error('Illegal escape in patch_fromText: ' + line); + } + if (sign == '-') { + // Deletion. + patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line)); + } else if (sign == '+') { + // Insertion. + patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line)); + } else if (sign == ' ') { + // Minor equality. + patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line)); + } else if (sign == '@') { + // Start of next patch. + break; + } else if (sign === '') { + // Blank line? Whatever. + } else { + // WTF? + throw new Error('Invalid patch mode "' + sign + '" in: ' + line); + } + textPointer++; + } + } + return patches; +}; + + +/** + * Class representing one patch operation. + * @constructor + */ +diff_match_patch.patch_obj = function() { + /** @type {!Array.} */ + this.diffs = []; + /** @type {?number} */ + this.start1 = null; + /** @type {?number} */ + this.start2 = null; + /** @type {number} */ + this.length1 = 0; + /** @type {number} */ + this.length2 = 0; +}; + + +/** + * Emulate GNU diff's format. + * Header: @@ -382,8 +481,9 @@ + * Indices are printed as 1-based, not 0-based. + * @return {string} The GNU diff string. + */ +diff_match_patch.patch_obj.prototype.toString = function() { + var coords1, coords2; + if (this.length1 === 0) { + coords1 = this.start1 + ',0'; + } else if (this.length1 == 1) { + coords1 = this.start1 + 1; + } else { + coords1 = (this.start1 + 1) + ',' + this.length1; + } + if (this.length2 === 0) { + coords2 = this.start2 + ',0'; + } else if (this.length2 == 1) { + coords2 = this.start2 + 1; + } else { + coords2 = (this.start2 + 1) + ',' + this.length2; + } + var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n']; + var op; + // Escape the body of the patch with %xx notation. + for (var x = 0; x < this.diffs.length; x++) { + switch (this.diffs[x][0]) { + case DIFF_INSERT: + op = '+'; + break; + case DIFF_DELETE: + op = '-'; + break; + case DIFF_EQUAL: + op = ' '; + break; + } + text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n'; + } + return text.join('').replace(/%20/g, ' '); +}; + + +// The following export code was added by @ForbesLindesay +module.exports = diff_match_patch; +module.exports.diff_match_patch = diff_match_patch; +module.exports.DIFF_DELETE = DIFF_DELETE; +module.exports.DIFF_INSERT = DIFF_INSERT; +module.exports.DIFF_EQUAL = DIFF_EQUAL; + +/***/ }), + +/***/ 9208: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/** + * lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright jQuery Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the `TypeError` message for "Functions" methods. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** `Object#toString` result references. */ +var funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + symbolTag = '[object Symbol]'; + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/, + reLeadingDot = /^\./, + rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Checks if `value` is a host object in IE < 9. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a host object, else `false`. + */ +function isHostObject(value) { + // Many host objects are `Object` objects that can coerce to strings + // despite having improperly defined `toString` methods. + var result = false; + if (value != null && typeof value.toString != 'function') { + try { + result = !!(value + ''); + } catch (e) {} + } + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var objectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var Symbol = root.Symbol, + splice = arrayProto.splice; + +/* Built-in method references that are verified to be native. */ +var Map = getNative(root, 'Map'), + nativeCreate = getNative(Object, 'create'); + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + return this.has(key) && delete this.__data__[key]; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries ? entries.length : 0; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + return getMapData(this, key)['delete'](key); +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + getMapData(this, key).set(key, value); + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ +function baseGet(object, path) { + path = isKey(path, object) ? [path] : castPath(path); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value) { + return isArray(value) ? value : stringToPath(value); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoize(function(string) { + string = toString(string); + + var result = []; + if (reLeadingDot.test(string)) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, string) { + result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to process. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result); + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} + +// Assign cache to `_.memoize`. +memoize.Cache = MapCache; + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 8-9 which returns 'object' for typed array and other constructors. + var tag = isObject(value) ? objectToString.call(value) : ''; + return tag == funcTag || tag == genTag; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return !!value && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return !!value && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && objectToString.call(value) == symbolTag); +} + +/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to process. + * @returns {string} Returns the string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ +function toString(value) { + return value == null ? '' : baseToString(value); +} + +/** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ +function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; +} + +module.exports = get; + + +/***/ }), + +/***/ 2307: +/***/ (function(module, exports, __webpack_require__) { + +/* module decorator */ module = __webpack_require__.nmd(module); +/** + * Lodash (Custom Build) + * Build: `lodash modularize exports="npm" -o ./` + * Copyright JS Foundation and other contributors + * Released under MIT license + * Based on Underscore.js 1.8.3 + * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors + */ + +/** Used as the size to enable large array optimizations. */ +var LARGE_ARRAY_SIZE = 200; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + asyncTag = '[object AsyncFunction]', + boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + funcTag = '[object Function]', + genTag = '[object GeneratorFunction]', + mapTag = '[object Map]', + numberTag = '[object Number]', + nullTag = '[object Null]', + objectTag = '[object Object]', + promiseTag = '[object Promise]', + proxyTag = '[object Proxy]', + regexpTag = '[object RegExp]', + setTag = '[object Set]', + stringTag = '[object String]', + symbolTag = '[object Symbol]', + undefinedTag = '[object Undefined]', + weakMapTag = '[object WeakMap]'; + +var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + +/** Used to identify `toStringTag` values of typed arrays. */ +var typedArrayTags = {}; +typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = +typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = +typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = +typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = +typedArrayTags[uint32Tag] = true; +typedArrayTags[argsTag] = typedArrayTags[arrayTag] = +typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = +typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = +typedArrayTags[errorTag] = typedArrayTags[funcTag] = +typedArrayTags[mapTag] = typedArrayTags[numberTag] = +typedArrayTags[objectTag] = typedArrayTags[regexpTag] = +typedArrayTags[setTag] = typedArrayTags[stringTag] = +typedArrayTags[weakMapTag] = false; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal || freeSelf || Function('return this')(); + +/** Detect free variable `exports`. */ +var freeExports = true && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; + +/** Detect free variable `process` from Node.js. */ +var freeProcess = moduleExports && freeGlobal.process; + +/** Used to access faster Node.js helpers. */ +var nodeUtil = (function() { + try { + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} +}()); + +/* Node.js helper references. */ +var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; + +/** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ +function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; +} + +/** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ +function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; +} + +/** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ +function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; +} + +/** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ +function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} + +/** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ +function baseUnary(func) { + return function(value) { + return func(value); + }; +} + +/** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function cacheHas(cache, key) { + return cache.has(key); +} + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ +function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; +} + +/** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ +function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; +} + +/** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ +function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype, + funcProto = Function.prototype, + objectProto = Object.prototype; + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root['__core-js_shared__']; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto.toString; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** Built-in value references. */ +var Buffer = moduleExports ? root.Buffer : undefined, + Symbol = root.Symbol, + Uint8Array = root.Uint8Array, + propertyIsEnumerable = objectProto.propertyIsEnumerable, + splice = arrayProto.splice, + symToStringTag = Symbol ? Symbol.toStringTag : undefined; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeGetSymbols = Object.getOwnPropertySymbols, + nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, + nativeKeys = overArg(Object.keys, Object); + +/* Built-in method references that are verified to be native. */ +var DataView = getNative(root, 'DataView'), + Map = getNative(root, 'Map'), + Promise = getNative(root, 'Promise'), + Set = getNative(root, 'Set'), + WeakMap = getNative(root, 'WeakMap'), + nativeCreate = getNative(Object, 'create'); + +/** Used to detect maps, sets, and weakmaps. */ +var dataViewCtorString = toSource(DataView), + mapCtorString = toSource(Map), + promiseCtorString = toSource(Promise), + setCtorString = toSource(Set), + weakMapCtorString = toSource(WeakMap); + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol ? Symbol.prototype : undefined, + symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate ? nativeCreate(null) : {}; + this.size = 0; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate) { + var result = data[key]; + return result === HASH_UNDEFINED ? undefined : result; + } + return hasOwnProperty.call(data, key) ? data[key] : undefined; +} + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); +} + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; + return this; +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; + this.size = 0; +} + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map || ListCache), + 'string': new Hash + }; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ +function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } +} + +/** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ +function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; +} + +/** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ +function setCacheHas(value) { + return this.__data__.has(value); +} + +// Add methods to `SetCache`. +SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; +SetCache.prototype.has = setCacheHas; + +/** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; +} + +/** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ +function stackClear() { + this.__data__ = new ListCache; + this.size = 0; +} + +/** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; +} + +/** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function stackGet(key) { + return this.__data__.get(key); +} + +/** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function stackHas(key) { + return this.__data__.has(key); +} + +/** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ +function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; +} + +// Add methods to `Stack`. +Stack.prototype.clear = stackClear; +Stack.prototype['delete'] = stackDelete; +Stack.prototype.get = stackGet; +Stack.prototype.has = stackHas; +Stack.prototype.set = stackSet; + +/** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ +function arrayLikeKeys(value, inherited) { + var isArr = isArray(value), + isArg = !isArr && isArguments(value), + isBuff = !isArr && !isArg && isBuffer(value), + isType = !isArr && !isArg && !isBuff && isTypedArray(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; +} + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ +function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); +} + +/** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString(value); +} + +/** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag; +} + +/** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ +function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); +} + +/** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray(object), + othIsArr = isArray(other), + objTag = objIsArr ? arrayTag : getTag(object), + othTag = othIsArr ? arrayTag : getTag(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer(object)) { + if (!isBuffer(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); +} + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ +function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} + +/** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; +} + +/** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ +function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(array); + if (stacked && stack.get(other)) { + return stacked == other; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; +} + +/** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array(object), new Uint8Array(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag: + var convert = mapToArray; + + case setTag: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; +} + +/** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { + return false; + } + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked && stack.get(other)) { + return stacked == other; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; +} + +/** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ +function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ +function getRawTag(value) { + var isOwn = hasOwnProperty.call(value, symToStringTag), + tag = value[symToStringTag]; + + try { + value[symToStringTag] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag] = tag; + } else { + delete value[symToStringTag]; + } + } + return result; +} + +/** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ +var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); +}; + +/** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +var getTag = baseGetTag; + +// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. +if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || + (Map && getTag(new Map) != mapTag) || + (Promise && getTag(Promise.resolve()) != promiseTag) || + (Set && getTag(new Set) != setTag) || + (WeakMap && getTag(new WeakMap) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; +} + +/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ +function isIndex(value, length) { + length = length == null ? MAX_SAFE_INTEGER : length; + return !!length && + (typeof value == 'number' || reIsUint.test(value)) && + (value > -1 && value % 1 == 0 && value < length); +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ +function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; + + return value === proto; +} + +/** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ +function objectToString(value) { + return nativeObjectToString.call(value); +} + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ +var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && + !propertyIsEnumerable.call(value, 'callee'); +}; + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray = Array.isArray; + +/** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); +} + +/** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ +var isBuffer = nativeIsBuffer || stubFalse; + +/** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ +function isEqual(value, other) { + return baseIsEqual(value, other); +} + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + if (!isObject(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; +} + +/** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ +function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return value != null && typeof value == 'object'; +} + +/** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + +/** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ +function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} + +/** + * This method returns a new empty array. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {Array} Returns the new empty array. + * @example + * + * var arrays = _.times(2, _.stubArray); + * + * console.log(arrays); + * // => [[], []] + * + * console.log(arrays[0] === arrays[1]); + * // => false + */ +function stubArray() { + return []; +} + +/** + * This method returns `false`. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. + * @example + * + * _.times(2, _.stubFalse); + * // => [false, false] + */ +function stubFalse() { + return false; +} + +module.exports = isEqual; + + +/***/ }), + +/***/ 2703: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret = __webpack_require__(414); + +function emptyFunction() {} +function emptyFunctionWithReset() {} +emptyFunctionWithReset.resetWarningCache = emptyFunction; + +module.exports = function() { + function shim(props, propName, componentName, location, propFullName, secret) { + if (secret === ReactPropTypesSecret) { + // It is still safe when called from React. + return; + } + var err = new Error( + 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + + 'Use PropTypes.checkPropTypes() to call them. ' + + 'Read more at http://fb.me/use-check-prop-types' + ); + err.name = 'Invariant Violation'; + throw err; + }; + shim.isRequired = shim; + function getShim() { + return shim; + }; + // Important! + // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. + var ReactPropTypes = { + array: shim, + bigint: shim, + bool: shim, + func: shim, + number: shim, + object: shim, + string: shim, + symbol: shim, + + any: shim, + arrayOf: getShim, + element: shim, + elementType: shim, + instanceOf: getShim, + node: shim, + objectOf: getShim, + oneOf: getShim, + oneOfType: getShim, + shape: getShim, + exact: getShim, + + checkPropTypes: emptyFunctionWithReset, + resetWarningCache: emptyFunction + }; + + ReactPropTypes.PropTypes = ReactPropTypes; + + return ReactPropTypes; +}; + + +/***/ }), + +/***/ 5697: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + +if (false) { var throwOnDirectAccess, ReactIs; } else { + // By explicitly using `prop-types` you are opting into new production behavior. + // http://fb.me/prop-types-in-prod + module.exports = __webpack_require__(2703)(); +} + + +/***/ }), + +/***/ 414: +/***/ (function(module) { + +"use strict"; +/** + * Copyright (c) 2013-present, Facebook, Inc. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ + + + +var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; + +module.exports = ReactPropTypesSecret; + + +/***/ }), + +/***/ 3946: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var ace_builds_1 = __webpack_require__(3239); +var PropTypes = __webpack_require__(5697); +var React = __webpack_require__(7294); +var isEqual = __webpack_require__(2307); +var editorOptions_1 = __webpack_require__(1048); +var ace = (0, editorOptions_1.getAceInstance)(); +var ReactAce = /** @class */ (function (_super) { + __extends(ReactAce, _super); + function ReactAce(props) { + var _this = _super.call(this, props) || this; + editorOptions_1.editorEvents.forEach(function (method) { + _this[method] = _this[method].bind(_this); + }); + _this.debounce = editorOptions_1.debounce; + return _this; + } + ReactAce.prototype.isInShadow = function (node) { + var parent = node && node.parentNode; + while (parent) { + if (parent.toString() === "[object ShadowRoot]") { + return true; + } + parent = parent.parentNode; + } + return false; + }; + ReactAce.prototype.componentDidMount = function () { + var _this = this; + var _a = this.props, className = _a.className, onBeforeLoad = _a.onBeforeLoad, onValidate = _a.onValidate, mode = _a.mode, focus = _a.focus, theme = _a.theme, fontSize = _a.fontSize, value = _a.value, defaultValue = _a.defaultValue, showGutter = _a.showGutter, wrapEnabled = _a.wrapEnabled, showPrintMargin = _a.showPrintMargin, _b = _a.scrollMargin, scrollMargin = _b === void 0 ? [0, 0, 0, 0] : _b, keyboardHandler = _a.keyboardHandler, onLoad = _a.onLoad, commands = _a.commands, annotations = _a.annotations, markers = _a.markers, placeholder = _a.placeholder; + this.editor = ace.edit(this.refEditor); + if (onBeforeLoad) { + onBeforeLoad(ace); + } + var editorProps = Object.keys(this.props.editorProps); + for (var i = 0; i < editorProps.length; i++) { + this.editor[editorProps[i]] = this.props.editorProps[editorProps[i]]; + } + if (this.props.debounceChangePeriod) { + this.onChange = this.debounce(this.onChange, this.props.debounceChangePeriod); + } + this.editor.renderer.setScrollMargin(scrollMargin[0], scrollMargin[1], scrollMargin[2], scrollMargin[3]); + if (this.isInShadow(this.refEditor)) { + this.editor.renderer.attachToShadowRoot(); + } + this.editor + .getSession() + .setMode(typeof mode === "string" ? "ace/mode/" + mode : mode); + if (theme && theme !== "") + this.editor.setTheme("ace/theme/" + theme); + this.editor.setFontSize(typeof fontSize === "number" ? fontSize + "px" : fontSize); + this.editor + .getSession() + .setValue(!defaultValue ? value || "" : defaultValue); + if (this.props.navigateToFileEnd) { + this.editor.navigateFileEnd(); + } + this.editor.renderer.setShowGutter(showGutter); + this.editor.getSession().setUseWrapMode(wrapEnabled); + this.editor.setShowPrintMargin(showPrintMargin); + this.editor.on("focus", this.onFocus); + this.editor.on("blur", this.onBlur); + this.editor.on("copy", this.onCopy); + this.editor.on("paste", this.onPaste); + this.editor.on("change", this.onChange); + this.editor.on("input", this.onInput); + if (placeholder) { + this.updatePlaceholder(); + } + this.editor + .getSession() + .selection.on("changeSelection", this.onSelectionChange); + this.editor.getSession().selection.on("changeCursor", this.onCursorChange); + if (onValidate) { + // @ts-ignore types don't include + this.editor.getSession().on("changeAnnotation", function () { + // tslint:disable-next-line:no-shadowed-variable + var annotations = _this.editor.getSession().getAnnotations(); + _this.props.onValidate(annotations); + }); + } + this.editor.session.on("changeScrollTop", this.onScroll); + this.editor.getSession().setAnnotations(annotations || []); + if (markers && markers.length > 0) { + this.handleMarkers(markers); + } + // get a list of possible options to avoid 'misspelled option errors' + var availableOptions = this.editor.$options; + editorOptions_1.editorOptions.forEach(function (option) { + if (availableOptions.hasOwnProperty(option)) { + // @ts-ignore + _this.editor.setOption(option, _this.props[option]); + } + else if (_this.props[option]) { + console.warn("ReactAce: editor option " + option + " was activated but not found. Did you need to import a related tool or did you possibly mispell the option?"); + } + }); + this.handleOptions(this.props); + if (Array.isArray(commands)) { + commands.forEach(function (command) { + if (typeof command.exec === "string") { + _this.editor.commands.bindKey(command.bindKey, command.exec); + } + else { + _this.editor.commands.addCommand(command); + } + }); + } + if (keyboardHandler) { + this.editor.setKeyboardHandler("ace/keyboard/" + keyboardHandler); + } + if (className) { + this.refEditor.className += " " + className; + } + if (onLoad) { + onLoad(this.editor); + } + this.editor.resize(); + if (focus) { + this.editor.focus(); + } + }; + ReactAce.prototype.componentDidUpdate = function (prevProps) { + var oldProps = prevProps; + var nextProps = this.props; + for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { + var option = editorOptions_1.editorOptions[i]; + if (nextProps[option] !== oldProps[option]) { + // @ts-ignore + this.editor.setOption(option, nextProps[option]); + } + } + if (nextProps.className !== oldProps.className) { + var appliedClasses = this.refEditor.className; + var appliedClassesArray_1 = appliedClasses.trim().split(" "); + var oldClassesArray = oldProps.className.trim().split(" "); + oldClassesArray.forEach(function (oldClass) { + var index = appliedClassesArray_1.indexOf(oldClass); + appliedClassesArray_1.splice(index, 1); + }); + this.refEditor.className = + " " + nextProps.className + " " + appliedClassesArray_1.join(" "); + } + // First process editor value, as it may create a new session (see issue #300) + if (this.editor && + nextProps.value != null && + this.editor.getValue() !== nextProps.value) { + // editor.setValue is a synchronous function call, change event is emitted before setValue return. + this.silent = true; + var pos = this.editor.session.selection.toJSON(); + this.editor.setValue(nextProps.value, nextProps.cursorStart); + this.editor.session.selection.fromJSON(pos); + this.silent = false; + } + if (nextProps.placeholder !== oldProps.placeholder) { + this.updatePlaceholder(); + } + if (nextProps.mode !== oldProps.mode) { + this.editor + .getSession() + .setMode(typeof nextProps.mode === "string" + ? "ace/mode/" + nextProps.mode + : nextProps.mode); + } + if (nextProps.theme !== oldProps.theme) { + this.editor.setTheme("ace/theme/" + nextProps.theme); + } + if (nextProps.keyboardHandler !== oldProps.keyboardHandler) { + if (nextProps.keyboardHandler) { + this.editor.setKeyboardHandler("ace/keyboard/" + nextProps.keyboardHandler); + } + else { + this.editor.setKeyboardHandler(null); + } + } + if (nextProps.fontSize !== oldProps.fontSize) { + this.editor.setFontSize(typeof nextProps.fontSize === "number" + ? nextProps.fontSize + "px" + : nextProps.fontSize); + } + if (nextProps.wrapEnabled !== oldProps.wrapEnabled) { + this.editor.getSession().setUseWrapMode(nextProps.wrapEnabled); + } + if (nextProps.showPrintMargin !== oldProps.showPrintMargin) { + this.editor.setShowPrintMargin(nextProps.showPrintMargin); + } + if (nextProps.showGutter !== oldProps.showGutter) { + this.editor.renderer.setShowGutter(nextProps.showGutter); + } + if (!isEqual(nextProps.setOptions, oldProps.setOptions)) { + this.handleOptions(nextProps); + } + if (!isEqual(nextProps.annotations, oldProps.annotations)) { + this.editor.getSession().setAnnotations(nextProps.annotations || []); + } + if (!isEqual(nextProps.markers, oldProps.markers) && + Array.isArray(nextProps.markers)) { + this.handleMarkers(nextProps.markers); + } + // this doesn't look like it works at all.... + if (!isEqual(nextProps.scrollMargin, oldProps.scrollMargin)) { + this.handleScrollMargins(nextProps.scrollMargin); + } + if (prevProps.height !== this.props.height || + prevProps.width !== this.props.width) { + this.editor.resize(); + } + if (this.props.focus && !prevProps.focus) { + this.editor.focus(); + } + }; + ReactAce.prototype.handleScrollMargins = function (margins) { + if (margins === void 0) { margins = [0, 0, 0, 0]; } + this.editor.renderer.setScrollMargin(margins[0], margins[1], margins[2], margins[3]); + }; + ReactAce.prototype.componentWillUnmount = function () { + this.editor.destroy(); + this.editor = null; + }; + ReactAce.prototype.onChange = function (event) { + if (this.props.onChange && !this.silent) { + var value = this.editor.getValue(); + this.props.onChange(value, event); + } + }; + ReactAce.prototype.onSelectionChange = function (event) { + if (this.props.onSelectionChange) { + var value = this.editor.getSelection(); + this.props.onSelectionChange(value, event); + } + }; + ReactAce.prototype.onCursorChange = function (event) { + if (this.props.onCursorChange) { + var value = this.editor.getSelection(); + this.props.onCursorChange(value, event); + } + }; + ReactAce.prototype.onInput = function (event) { + if (this.props.onInput) { + this.props.onInput(event); + } + if (this.props.placeholder) { + this.updatePlaceholder(); + } + }; + ReactAce.prototype.onFocus = function (event) { + if (this.props.onFocus) { + this.props.onFocus(event, this.editor); + } + }; + ReactAce.prototype.onBlur = function (event) { + if (this.props.onBlur) { + this.props.onBlur(event, this.editor); + } + }; + ReactAce.prototype.onCopy = function (_a) { + var text = _a.text; + if (this.props.onCopy) { + this.props.onCopy(text); + } + }; + ReactAce.prototype.onPaste = function (_a) { + var text = _a.text; + if (this.props.onPaste) { + this.props.onPaste(text); + } + }; + ReactAce.prototype.onScroll = function () { + if (this.props.onScroll) { + this.props.onScroll(this.editor); + } + }; + ReactAce.prototype.handleOptions = function (props) { + var setOptions = Object.keys(props.setOptions); + for (var y = 0; y < setOptions.length; y++) { + // @ts-ignore + this.editor.setOption(setOptions[y], props.setOptions[setOptions[y]]); + } + }; + ReactAce.prototype.handleMarkers = function (markers) { + var _this = this; + // remove foreground markers + var currentMarkers = this.editor.getSession().getMarkers(true); + for (var i in currentMarkers) { + if (currentMarkers.hasOwnProperty(i)) { + this.editor.getSession().removeMarker(currentMarkers[i].id); + } + } + // remove background markers except active line marker and selected word marker + currentMarkers = this.editor.getSession().getMarkers(false); + for (var i in currentMarkers) { + if (currentMarkers.hasOwnProperty(i) && + currentMarkers[i].clazz !== "ace_active-line" && + currentMarkers[i].clazz !== "ace_selected-word") { + this.editor.getSession().removeMarker(currentMarkers[i].id); + } + } + // add new markers + markers.forEach(function (_a) { + var startRow = _a.startRow, startCol = _a.startCol, endRow = _a.endRow, endCol = _a.endCol, className = _a.className, type = _a.type, _b = _a.inFront, inFront = _b === void 0 ? false : _b; + var range = new ace_builds_1.Range(startRow, startCol, endRow, endCol); + _this.editor.getSession().addMarker(range, className, type, inFront); + }); + }; + ReactAce.prototype.updatePlaceholder = function () { + // Adapted from https://stackoverflow.com/questions/26695708/how-can-i-add-placeholder-text-when-the-editor-is-empty + var editor = this.editor; + var placeholder = this.props.placeholder; + var showPlaceholder = !editor.session.getValue().length; + var node = editor.renderer.placeholderNode; + if (!showPlaceholder && node) { + editor.renderer.scroller.removeChild(editor.renderer.placeholderNode); + editor.renderer.placeholderNode = null; + } + else if (showPlaceholder && !node) { + node = editor.renderer.placeholderNode = document.createElement("div"); + node.textContent = placeholder || ""; + node.className = "ace_comment ace_placeholder"; + node.style.padding = "0 9px"; + node.style.position = "absolute"; + node.style.zIndex = "3"; + editor.renderer.scroller.appendChild(node); + } + else if (showPlaceholder && node) { + node.textContent = placeholder; + } + }; + ReactAce.prototype.updateRef = function (item) { + this.refEditor = item; + }; + ReactAce.prototype.render = function () { + var _a = this.props, name = _a.name, width = _a.width, height = _a.height, style = _a.style; + var divStyle = __assign({ width: width, height: height }, style); + return React.createElement("div", { ref: this.updateRef, id: name, style: divStyle }); + }; + ReactAce.propTypes = { + mode: PropTypes.oneOfType([PropTypes.string, PropTypes.object]), + focus: PropTypes.bool, + theme: PropTypes.string, + name: PropTypes.string, + className: PropTypes.string, + height: PropTypes.string, + width: PropTypes.string, + fontSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]), + showGutter: PropTypes.bool, + onChange: PropTypes.func, + onCopy: PropTypes.func, + onPaste: PropTypes.func, + onFocus: PropTypes.func, + onInput: PropTypes.func, + onBlur: PropTypes.func, + onScroll: PropTypes.func, + value: PropTypes.string, + defaultValue: PropTypes.string, + onLoad: PropTypes.func, + onSelectionChange: PropTypes.func, + onCursorChange: PropTypes.func, + onBeforeLoad: PropTypes.func, + onValidate: PropTypes.func, + minLines: PropTypes.number, + maxLines: PropTypes.number, + readOnly: PropTypes.bool, + highlightActiveLine: PropTypes.bool, + tabSize: PropTypes.number, + showPrintMargin: PropTypes.bool, + cursorStart: PropTypes.number, + debounceChangePeriod: PropTypes.number, + editorProps: PropTypes.object, + setOptions: PropTypes.object, + style: PropTypes.object, + scrollMargin: PropTypes.array, + annotations: PropTypes.array, + markers: PropTypes.array, + keyboardHandler: PropTypes.string, + wrapEnabled: PropTypes.bool, + enableSnippets: PropTypes.bool, + enableBasicAutocompletion: PropTypes.oneOfType([ + PropTypes.bool, + PropTypes.array + ]), + enableLiveAutocompletion: PropTypes.oneOfType([ + PropTypes.bool, + PropTypes.array + ]), + navigateToFileEnd: PropTypes.bool, + commands: PropTypes.array, + placeholder: PropTypes.string + }; + ReactAce.defaultProps = { + name: "ace-editor", + focus: false, + mode: "", + theme: "", + height: "500px", + width: "500px", + fontSize: 12, + enableSnippets: false, + showGutter: true, + onChange: null, + onPaste: null, + onLoad: null, + onScroll: null, + minLines: null, + maxLines: null, + readOnly: false, + highlightActiveLine: true, + showPrintMargin: true, + tabSize: 4, + cursorStart: 1, + editorProps: {}, + style: {}, + scrollMargin: [0, 0, 0, 0], + setOptions: {}, + wrapEnabled: false, + enableBasicAutocompletion: false, + enableLiveAutocompletion: false, + placeholder: null, + navigateToFileEnd: true + }; + return ReactAce; +}(React.Component)); +exports["default"] = ReactAce; +//# sourceMappingURL=ace.js.map + +/***/ }), + +/***/ 3532: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +Object.defineProperty(exports, "__esModule", ({ value: true })); +var PropTypes = __webpack_require__(5697); +var React = __webpack_require__(7294); +var split_1 = __webpack_require__(8663); +var DiffMatchPatch = __webpack_require__(2027); +var DiffComponent = /** @class */ (function (_super) { + __extends(DiffComponent, _super); + function DiffComponent(props) { + var _this = _super.call(this, props) || this; + _this.state = { + value: _this.props.value + }; + _this.onChange = _this.onChange.bind(_this); + _this.diff = _this.diff.bind(_this); + return _this; + } + DiffComponent.prototype.componentDidUpdate = function () { + var value = this.props.value; + if (value !== this.state.value) { + this.setState({ value: value }); + } + }; + DiffComponent.prototype.onChange = function (value) { + this.setState({ + value: value + }); + if (this.props.onChange) { + this.props.onChange(value); + } + }; + DiffComponent.prototype.diff = function () { + var dmp = new DiffMatchPatch(); + var lhString = this.state.value[0]; + var rhString = this.state.value[1]; + if (lhString.length === 0 && rhString.length === 0) { + return []; + } + var diff = dmp.diff_main(lhString, rhString); + dmp.diff_cleanupSemantic(diff); + var diffedLines = this.generateDiffedLines(diff); + var codeEditorSettings = this.setCodeMarkers(diffedLines); + return codeEditorSettings; + }; + DiffComponent.prototype.generateDiffedLines = function (diff) { + var C = { + DIFF_EQUAL: 0, + DIFF_DELETE: -1, + DIFF_INSERT: 1 + }; + var diffedLines = { + left: [], + right: [] + }; + var cursor = { + left: 1, + right: 1 + }; + diff.forEach(function (chunk) { + var chunkType = chunk[0]; + var text = chunk[1]; + var lines = text.split("\n").length - 1; + // diff-match-patch sometimes returns empty strings at random + if (text.length === 0) { + return; + } + var firstChar = text[0]; + var lastChar = text[text.length - 1]; + var linesToHighlight = 0; + switch (chunkType) { + case C.DIFF_EQUAL: + cursor.left += lines; + cursor.right += lines; + break; + case C.DIFF_DELETE: + // If the deletion starts with a newline, push the cursor down to that line + if (firstChar === "\n") { + cursor.left++; + lines--; + } + linesToHighlight = lines; + // If the deletion does not include a newline, highlight the same line on the right + if (linesToHighlight === 0) { + diffedLines.right.push({ + startLine: cursor.right, + endLine: cursor.right + }); + } + // If the last character is a newline, we don't want to highlight that line + if (lastChar === "\n") { + linesToHighlight -= 1; + } + diffedLines.left.push({ + startLine: cursor.left, + endLine: cursor.left + linesToHighlight + }); + cursor.left += lines; + break; + case C.DIFF_INSERT: + // If the insertion starts with a newline, push the cursor down to that line + if (firstChar === "\n") { + cursor.right++; + lines--; + } + linesToHighlight = lines; + // If the insertion does not include a newline, highlight the same line on the left + if (linesToHighlight === 0) { + diffedLines.left.push({ + startLine: cursor.left, + endLine: cursor.left + }); + } + // If the last character is a newline, we don't want to highlight that line + if (lastChar === "\n") { + linesToHighlight -= 1; + } + diffedLines.right.push({ + startLine: cursor.right, + endLine: cursor.right + linesToHighlight + }); + cursor.right += lines; + break; + default: + throw new Error("Diff type was not defined."); + } + }); + return diffedLines; + }; + // Receives a collection of line numbers and iterates through them to highlight appropriately + // Returns an object that tells the render() method how to display the code editors + DiffComponent.prototype.setCodeMarkers = function (diffedLines) { + if (diffedLines === void 0) { diffedLines = { left: [], right: [] }; } + var codeEditorSettings = []; + var newMarkerSet = { + left: [], + right: [] + }; + for (var i = 0; i < diffedLines.left.length; i++) { + var markerObj = { + startRow: diffedLines.left[i].startLine - 1, + endRow: diffedLines.left[i].endLine, + type: "text", + className: "codeMarker" + }; + newMarkerSet.left.push(markerObj); + } + for (var i = 0; i < diffedLines.right.length; i++) { + var markerObj = { + startRow: diffedLines.right[i].startLine - 1, + endRow: diffedLines.right[i].endLine, + type: "text", + className: "codeMarker" + }; + newMarkerSet.right.push(markerObj); + } + codeEditorSettings[0] = newMarkerSet.left; + codeEditorSettings[1] = newMarkerSet.right; + return codeEditorSettings; + }; + DiffComponent.prototype.render = function () { + var markers = this.diff(); + return (React.createElement(split_1.default, { name: this.props.name, className: this.props.className, focus: this.props.focus, orientation: this.props.orientation, splits: this.props.splits, mode: this.props.mode, theme: this.props.theme, height: this.props.height, width: this.props.width, fontSize: this.props.fontSize, showGutter: this.props.showGutter, onChange: this.onChange, onPaste: this.props.onPaste, onLoad: this.props.onLoad, onScroll: this.props.onScroll, minLines: this.props.minLines, maxLines: this.props.maxLines, readOnly: this.props.readOnly, highlightActiveLine: this.props.highlightActiveLine, showPrintMargin: this.props.showPrintMargin, tabSize: this.props.tabSize, cursorStart: this.props.cursorStart, editorProps: this.props.editorProps, style: this.props.style, scrollMargin: this.props.scrollMargin, setOptions: this.props.setOptions, wrapEnabled: this.props.wrapEnabled, enableBasicAutocompletion: this.props.enableBasicAutocompletion, enableLiveAutocompletion: this.props.enableLiveAutocompletion, value: this.state.value, markers: markers })); + }; + DiffComponent.propTypes = { + cursorStart: PropTypes.number, + editorProps: PropTypes.object, + enableBasicAutocompletion: PropTypes.bool, + enableLiveAutocompletion: PropTypes.bool, + focus: PropTypes.bool, + fontSize: PropTypes.number, + height: PropTypes.string, + highlightActiveLine: PropTypes.bool, + maxLines: PropTypes.number, + minLines: PropTypes.number, + mode: PropTypes.string, + name: PropTypes.string, + className: PropTypes.string, + onLoad: PropTypes.func, + onPaste: PropTypes.func, + onScroll: PropTypes.func, + onChange: PropTypes.func, + orientation: PropTypes.string, + readOnly: PropTypes.bool, + scrollMargin: PropTypes.array, + setOptions: PropTypes.object, + showGutter: PropTypes.bool, + showPrintMargin: PropTypes.bool, + splits: PropTypes.number, + style: PropTypes.object, + tabSize: PropTypes.number, + theme: PropTypes.string, + value: PropTypes.array, + width: PropTypes.string, + wrapEnabled: PropTypes.bool + }; + DiffComponent.defaultProps = { + cursorStart: 1, + editorProps: {}, + enableBasicAutocompletion: false, + enableLiveAutocompletion: false, + focus: false, + fontSize: 12, + height: "500px", + highlightActiveLine: true, + maxLines: null, + minLines: null, + mode: "", + name: "ace-editor", + onLoad: null, + onScroll: null, + onPaste: null, + onChange: null, + orientation: "beside", + readOnly: false, + scrollMargin: [0, 0, 0, 0], + setOptions: {}, + showGutter: true, + showPrintMargin: true, + splits: 2, + style: {}, + tabSize: 4, + theme: "github", + value: ["", ""], + width: "500px", + wrapEnabled: true + }; + return DiffComponent; +}(React.Component)); +exports["default"] = DiffComponent; +//# sourceMappingURL=diff.js.map + +/***/ }), + +/***/ 1048: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.getAceInstance = exports.debounce = exports.editorEvents = exports.editorOptions = void 0; +var editorOptions = [ + "minLines", + "maxLines", + "readOnly", + "highlightActiveLine", + "tabSize", + "enableBasicAutocompletion", + "enableLiveAutocompletion", + "enableSnippets" +]; +exports.editorOptions = editorOptions; +var editorEvents = [ + "onChange", + "onFocus", + "onInput", + "onBlur", + "onCopy", + "onPaste", + "onSelectionChange", + "onCursorChange", + "onScroll", + "handleOptions", + "updateRef" +]; +exports.editorEvents = editorEvents; +var getAceInstance = function () { + var ace; + if (typeof window === "undefined") { + // ace-builds just needs some window object to attach ace to. + // During SSR even just an empty object will work. + __webpack_require__.g.window = {}; + ace = __webpack_require__(3239); + // And it can be discarded immediately afterward to avoid confusing + // other libraries that might detect SSR the same way we did. + delete __webpack_require__.g.window; + } + else if (window.ace) { + // Fallback for ace.require when vanilla ACE is hosted over a CDN + ace = window.ace; + ace.acequire = window.ace.require || window.ace.acequire; + } + else { + ace = __webpack_require__(3239); + } + return ace; +}; +exports.getAceInstance = getAceInstance; +var debounce = function (fn, delay) { + var timer = null; + // tslint:disable-next-line + return function () { + var context = this; + var args = arguments; + clearTimeout(timer); + timer = setTimeout(function () { + fn.apply(context, args); + }, delay); + }; +}; +exports.debounce = debounce; +//# sourceMappingURL=editorOptions.js.map + +/***/ }), + +/***/ 4981: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ value: true })); +exports.diff = exports.split = void 0; +var ace_1 = __webpack_require__(3946); +var diff_1 = __webpack_require__(3532); +exports.diff = diff_1.default; +var split_1 = __webpack_require__(8663); +exports.split = split_1.default; +exports["default"] = ace_1.default; +//# sourceMappingURL=index.js.map + +/***/ }), + +/***/ 8663: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +var __assign = (this && this.__assign) || function () { + __assign = Object.assign || function(t) { + for (var s, i = 1, n = arguments.length; i < n; i++) { + s = arguments[i]; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) + t[p] = s[p]; + } + return t; + }; + return __assign.apply(this, arguments); +}; +Object.defineProperty(exports, "__esModule", ({ value: true })); +var editorOptions_1 = __webpack_require__(1048); +var ace = (0, editorOptions_1.getAceInstance)(); +var ace_builds_1 = __webpack_require__(3239); +var ext_split_1 = __webpack_require__(3083); +var PropTypes = __webpack_require__(5697); +var React = __webpack_require__(7294); +var isEqual = __webpack_require__(2307); +var get = __webpack_require__(9208); +var SplitComponent = /** @class */ (function (_super) { + __extends(SplitComponent, _super); + function SplitComponent(props) { + var _this = _super.call(this, props) || this; + editorOptions_1.editorEvents.forEach(function (method) { + _this[method] = _this[method].bind(_this); + }); + _this.debounce = editorOptions_1.debounce; + return _this; + } + SplitComponent.prototype.isInShadow = function (node) { + var parent = node && node.parentNode; + while (parent) { + if (parent.toString() === "[object ShadowRoot]") { + return true; + } + parent = parent.parentNode; + } + return false; + }; + SplitComponent.prototype.componentDidMount = function () { + var _this = this; + var _a = this.props, className = _a.className, onBeforeLoad = _a.onBeforeLoad, mode = _a.mode, focus = _a.focus, theme = _a.theme, fontSize = _a.fontSize, value = _a.value, defaultValue = _a.defaultValue, cursorStart = _a.cursorStart, showGutter = _a.showGutter, wrapEnabled = _a.wrapEnabled, showPrintMargin = _a.showPrintMargin, _b = _a.scrollMargin, scrollMargin = _b === void 0 ? [0, 0, 0, 0] : _b, keyboardHandler = _a.keyboardHandler, onLoad = _a.onLoad, commands = _a.commands, annotations = _a.annotations, markers = _a.markers, splits = _a.splits; + this.editor = ace.edit(this.refEditor); + if (this.isInShadow(this.refEditor)) { + this.editor.renderer.attachToShadowRoot(); + } + this.editor.setTheme("ace/theme/" + theme); + if (onBeforeLoad) { + onBeforeLoad(ace); + } + var editorProps = Object.keys(this.props.editorProps); + var split = new ext_split_1.Split(this.editor.container, "ace/theme/" + theme, splits); + this.editor.env.split = split; + this.splitEditor = split.getEditor(0); + this.split = split; + // in a split scenario we don't want a print margin for the entire application + this.editor.setShowPrintMargin(false); + this.editor.renderer.setShowGutter(false); + // get a list of possible options to avoid 'misspelled option errors' + var availableOptions = this.splitEditor.$options; + if (this.props.debounceChangePeriod) { + this.onChange = this.debounce(this.onChange, this.props.debounceChangePeriod); + } + split.forEach(function (editor, index) { + for (var i = 0; i < editorProps.length; i++) { + editor[editorProps[i]] = _this.props.editorProps[editorProps[i]]; + } + var defaultValueForEditor = get(defaultValue, index); + var valueForEditor = get(value, index, ""); + editor.session.setUndoManager(new ace.UndoManager()); + editor.setTheme("ace/theme/" + theme); + editor.renderer.setScrollMargin(scrollMargin[0], scrollMargin[1], scrollMargin[2], scrollMargin[3]); + editor.getSession().setMode("ace/mode/" + mode); + editor.setFontSize(fontSize); + editor.renderer.setShowGutter(showGutter); + editor.getSession().setUseWrapMode(wrapEnabled); + editor.setShowPrintMargin(showPrintMargin); + editor.on("focus", _this.onFocus); + editor.on("blur", _this.onBlur); + editor.on("input", _this.onInput); + editor.on("copy", _this.onCopy); + editor.on("paste", _this.onPaste); + editor.on("change", _this.onChange); + editor + .getSession() + .selection.on("changeSelection", _this.onSelectionChange); + editor.getSession().selection.on("changeCursor", _this.onCursorChange); + editor.session.on("changeScrollTop", _this.onScroll); + editor.setValue(defaultValueForEditor === undefined + ? valueForEditor + : defaultValueForEditor, cursorStart); + var newAnnotations = get(annotations, index, []); + var newMarkers = get(markers, index, []); + editor.getSession().setAnnotations(newAnnotations); + if (newMarkers && newMarkers.length > 0) { + _this.handleMarkers(newMarkers, editor); + } + for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { + var option = editorOptions_1.editorOptions[i]; + if (availableOptions.hasOwnProperty(option)) { + editor.setOption(option, _this.props[option]); + } + else if (_this.props[option]) { + console.warn("ReaceAce: editor option " + option + " was activated but not found. Did you need to import a related tool or did you possibly mispell the option?"); + } + } + _this.handleOptions(_this.props, editor); + if (Array.isArray(commands)) { + commands.forEach(function (command) { + if (typeof command.exec === "string") { + editor.commands.bindKey(command.bindKey, command.exec); + } + else { + editor.commands.addCommand(command); + } + }); + } + if (keyboardHandler) { + editor.setKeyboardHandler("ace/keyboard/" + keyboardHandler); + } + }); + if (className) { + this.refEditor.className += " " + className; + } + if (focus) { + this.splitEditor.focus(); + } + var sp = this.editor.env.split; + sp.setOrientation(this.props.orientation === "below" ? sp.BELOW : sp.BESIDE); + sp.resize(true); + if (onLoad) { + onLoad(sp); + } + }; + SplitComponent.prototype.componentDidUpdate = function (prevProps) { + var _this = this; + var oldProps = prevProps; + var nextProps = this.props; + var split = this.editor.env.split; + if (nextProps.splits !== oldProps.splits) { + split.setSplits(nextProps.splits); + } + if (nextProps.orientation !== oldProps.orientation) { + split.setOrientation(nextProps.orientation === "below" ? split.BELOW : split.BESIDE); + } + split.forEach(function (editor, index) { + if (nextProps.mode !== oldProps.mode) { + editor.getSession().setMode("ace/mode/" + nextProps.mode); + } + if (nextProps.keyboardHandler !== oldProps.keyboardHandler) { + if (nextProps.keyboardHandler) { + editor.setKeyboardHandler("ace/keyboard/" + nextProps.keyboardHandler); + } + else { + editor.setKeyboardHandler(null); + } + } + if (nextProps.fontSize !== oldProps.fontSize) { + editor.setFontSize(nextProps.fontSize); + } + if (nextProps.wrapEnabled !== oldProps.wrapEnabled) { + editor.getSession().setUseWrapMode(nextProps.wrapEnabled); + } + if (nextProps.showPrintMargin !== oldProps.showPrintMargin) { + editor.setShowPrintMargin(nextProps.showPrintMargin); + } + if (nextProps.showGutter !== oldProps.showGutter) { + editor.renderer.setShowGutter(nextProps.showGutter); + } + for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { + var option = editorOptions_1.editorOptions[i]; + if (nextProps[option] !== oldProps[option]) { + editor.setOption(option, nextProps[option]); + } + } + if (!isEqual(nextProps.setOptions, oldProps.setOptions)) { + _this.handleOptions(nextProps, editor); + } + var nextValue = get(nextProps.value, index, ""); + if (editor.getValue() !== nextValue) { + // editor.setValue is a synchronous function call, change event is emitted before setValue return. + _this.silent = true; + var pos = editor.session.selection.toJSON(); + editor.setValue(nextValue, nextProps.cursorStart); + editor.session.selection.fromJSON(pos); + _this.silent = false; + } + var newAnnotations = get(nextProps.annotations, index, []); + var oldAnnotations = get(oldProps.annotations, index, []); + if (!isEqual(newAnnotations, oldAnnotations)) { + editor.getSession().setAnnotations(newAnnotations); + } + var newMarkers = get(nextProps.markers, index, []); + var oldMarkers = get(oldProps.markers, index, []); + if (!isEqual(newMarkers, oldMarkers) && Array.isArray(newMarkers)) { + _this.handleMarkers(newMarkers, editor); + } + }); + if (nextProps.className !== oldProps.className) { + var appliedClasses = this.refEditor.className; + var appliedClassesArray_1 = appliedClasses.trim().split(" "); + var oldClassesArray = oldProps.className.trim().split(" "); + oldClassesArray.forEach(function (oldClass) { + var index = appliedClassesArray_1.indexOf(oldClass); + appliedClassesArray_1.splice(index, 1); + }); + this.refEditor.className = + " " + nextProps.className + " " + appliedClassesArray_1.join(" "); + } + if (nextProps.theme !== oldProps.theme) { + split.setTheme("ace/theme/" + nextProps.theme); + } + if (nextProps.focus && !oldProps.focus) { + this.splitEditor.focus(); + } + if (nextProps.height !== this.props.height || + nextProps.width !== this.props.width) { + this.editor.resize(); + } + }; + SplitComponent.prototype.componentWillUnmount = function () { + this.editor.destroy(); + this.editor = null; + }; + SplitComponent.prototype.onChange = function (event) { + if (this.props.onChange && !this.silent) { + var value_1 = []; + this.editor.env.split.forEach(function (editor) { + value_1.push(editor.getValue()); + }); + this.props.onChange(value_1, event); + } + }; + SplitComponent.prototype.onSelectionChange = function (event) { + if (this.props.onSelectionChange) { + var value_2 = []; + this.editor.env.split.forEach(function (editor) { + value_2.push(editor.getSelection()); + }); + this.props.onSelectionChange(value_2, event); + } + }; + SplitComponent.prototype.onCursorChange = function (event) { + if (this.props.onCursorChange) { + var value_3 = []; + this.editor.env.split.forEach(function (editor) { + value_3.push(editor.getSelection()); + }); + this.props.onCursorChange(value_3, event); + } + }; + SplitComponent.prototype.onFocus = function (event) { + if (this.props.onFocus) { + this.props.onFocus(event); + } + }; + SplitComponent.prototype.onInput = function (event) { + if (this.props.onInput) { + this.props.onInput(event); + } + }; + SplitComponent.prototype.onBlur = function (event) { + if (this.props.onBlur) { + this.props.onBlur(event); + } + }; + SplitComponent.prototype.onCopy = function (text) { + if (this.props.onCopy) { + this.props.onCopy(text); + } + }; + SplitComponent.prototype.onPaste = function (text) { + if (this.props.onPaste) { + this.props.onPaste(text); + } + }; + SplitComponent.prototype.onScroll = function () { + if (this.props.onScroll) { + this.props.onScroll(this.editor); + } + }; + SplitComponent.prototype.handleOptions = function (props, editor) { + var setOptions = Object.keys(props.setOptions); + for (var y = 0; y < setOptions.length; y++) { + editor.setOption(setOptions[y], props.setOptions[setOptions[y]]); + } + }; + SplitComponent.prototype.handleMarkers = function (markers, editor) { + // remove foreground markers + var currentMarkers = editor.getSession().getMarkers(true); + for (var i in currentMarkers) { + if (currentMarkers.hasOwnProperty(i)) { + editor.getSession().removeMarker(currentMarkers[i].id); + } + } + // remove background markers + currentMarkers = editor.getSession().getMarkers(false); + for (var i in currentMarkers) { + if (currentMarkers.hasOwnProperty(i)) { + editor.getSession().removeMarker(currentMarkers[i].id); + } + } + // add new markers + markers.forEach(function (_a) { + var startRow = _a.startRow, startCol = _a.startCol, endRow = _a.endRow, endCol = _a.endCol, className = _a.className, type = _a.type, _b = _a.inFront, inFront = _b === void 0 ? false : _b; + var range = new ace_builds_1.Range(startRow, startCol, endRow, endCol); + editor + .getSession() + .addMarker(range, className, type, inFront); + }); + }; + SplitComponent.prototype.updateRef = function (item) { + this.refEditor = item; + }; + SplitComponent.prototype.render = function () { + var _a = this.props, name = _a.name, width = _a.width, height = _a.height, style = _a.style; + var divStyle = __assign({ width: width, height: height }, style); + return React.createElement("div", { ref: this.updateRef, id: name, style: divStyle }); + }; + SplitComponent.propTypes = { + className: PropTypes.string, + debounceChangePeriod: PropTypes.number, + defaultValue: PropTypes.arrayOf(PropTypes.string), + focus: PropTypes.bool, + fontSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]), + height: PropTypes.string, + mode: PropTypes.string, + name: PropTypes.string, + onBlur: PropTypes.func, + onChange: PropTypes.func, + onCopy: PropTypes.func, + onFocus: PropTypes.func, + onInput: PropTypes.func, + onLoad: PropTypes.func, + onPaste: PropTypes.func, + onScroll: PropTypes.func, + orientation: PropTypes.string, + showGutter: PropTypes.bool, + splits: PropTypes.number, + theme: PropTypes.string, + value: PropTypes.arrayOf(PropTypes.string), + width: PropTypes.string, + onSelectionChange: PropTypes.func, + onCursorChange: PropTypes.func, + onBeforeLoad: PropTypes.func, + minLines: PropTypes.number, + maxLines: PropTypes.number, + readOnly: PropTypes.bool, + highlightActiveLine: PropTypes.bool, + tabSize: PropTypes.number, + showPrintMargin: PropTypes.bool, + cursorStart: PropTypes.number, + editorProps: PropTypes.object, + setOptions: PropTypes.object, + style: PropTypes.object, + scrollMargin: PropTypes.array, + annotations: PropTypes.array, + markers: PropTypes.array, + keyboardHandler: PropTypes.string, + wrapEnabled: PropTypes.bool, + enableBasicAutocompletion: PropTypes.oneOfType([ + PropTypes.bool, + PropTypes.array + ]), + enableLiveAutocompletion: PropTypes.oneOfType([ + PropTypes.bool, + PropTypes.array + ]), + commands: PropTypes.array + }; + SplitComponent.defaultProps = { + name: "ace-editor", + focus: false, + orientation: "beside", + splits: 2, + mode: "", + theme: "", + height: "500px", + width: "500px", + value: [], + fontSize: 12, + showGutter: true, + onChange: null, + onPaste: null, + onLoad: null, + onScroll: null, + minLines: null, + maxLines: null, + readOnly: false, + highlightActiveLine: true, + showPrintMargin: true, + tabSize: 4, + cursorStart: 1, + editorProps: {}, + style: {}, + scrollMargin: [0, 0, 0, 0], + setOptions: {}, + wrapEnabled: false, + enableBasicAutocompletion: false, + enableLiveAutocompletion: false + }; + return SplitComponent; +}(React.Component)); +exports["default"] = SplitComponent; +//# sourceMappingURL=split.js.map + +/***/ }) + +}]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js new file mode 100644 index 000000000000..935b6707472c --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js @@ -0,0 +1,226 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[888],{ + +/***/ 915: +/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + + + (window.__NEXT_P = window.__NEXT_P || []).push([ + "/_app", + function () { + return __webpack_require__(4297); + } + ]); + if(false) {} + + +/***/ }), + +/***/ 4297: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +var _runtimeJs = _interopRequireDefault(__webpack_require__(4051)); +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + return self; +} +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for(var i = 0; i < props.length; i++){ + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} +function _possibleConstructorReturn(self, call) { + if (call && (_typeof(call) === "object" || typeof call === "function")) { + return call; + } + return _assertThisInitialized(self); +} +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + return _setPrototypeOf(o, p); +} +var _typeof = function(obj) { + "@swc/helpers - typeof"; + return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; +}; +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + try { + Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})); + return true; + } catch (e) { + return false; + } +} +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), result; + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + return _possibleConstructorReturn(this, result); + }; +} +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +Object.defineProperty(exports, "AppInitialProps", ({ + enumerable: true, + get: function get() { + return _utils.AppInitialProps; + } +})); +Object.defineProperty(exports, "NextWebVitalsMetric", ({ + enumerable: true, + get: function get() { + return _utils.NextWebVitalsMetric; + } +})); +exports["default"] = void 0; +var _react = _interopRequireDefault1(__webpack_require__(7294)); +var _utils = __webpack_require__(670); +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} +function _asyncToGenerator(fn) { + return function() { + var self = this, args = arguments; + return new Promise(function(resolve, reject) { + var gen = fn.apply(self, args); + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + _next(undefined); + }); + }; +} +function _interopRequireDefault1(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} +function appGetInitialProps(_) { + return _appGetInitialProps.apply(this, arguments); +} +function _appGetInitialProps() { + _appGetInitialProps = /** + * `App` component is used for initialize of pages. It allows for overwriting and full control of the `page` initialization. + * This allows for keeping state between navigation, custom error handling, injecting additional data. + */ _asyncToGenerator(_runtimeJs.default.mark(function _callee(param) { + var Component, ctx, pageProps; + return _runtimeJs.default.wrap(function _callee$(_ctx) { + while(1)switch(_ctx.prev = _ctx.next){ + case 0: + Component = param.Component, ctx = param.ctx; + _ctx.next = 3; + return (0, _utils).loadGetInitialProps(Component, ctx); + case 3: + pageProps = _ctx.sent; + return _ctx.abrupt("return", { + pageProps: pageProps + }); + case 5: + case "end": + return _ctx.stop(); + } + }, _callee); + })); + return _appGetInitialProps.apply(this, arguments); +} +var App = /*#__PURE__*/ function(_Component) { + _inherits(App, _Component); + var _super = _createSuper(App); + function App() { + _classCallCheck(this, App); + return _super.apply(this, arguments); + } + _createClass(App, [ + { + key: "render", + value: function render() { + var _props = this.props, Component = _props.Component, pageProps = _props.pageProps; + return /*#__PURE__*/ _react.default.createElement(Component, Object.assign({}, pageProps)); + } + } + ]); + return App; +}(_react.default.Component); +exports["default"] = App; +App.origGetInitialProps = appGetInitialProps; +App.getInitialProps = appGetInitialProps; //# sourceMappingURL=_app.js.map + + +/***/ }) + +}, +/******/ function(__webpack_require__) { // webpackRuntimeModules +/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } +/******/ __webpack_require__.O(0, [774,179], function() { return __webpack_exec__(915), __webpack_exec__(880); }); +/******/ var __webpack_exports__ = __webpack_require__.O(); +/******/ _N_E = __webpack_exports__; +/******/ } +]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js new file mode 100644 index 000000000000..448527c7ff3a --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js @@ -0,0 +1,25 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[820],{ + +/***/ 4977: +/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + + + (window.__NEXT_P = window.__NEXT_P || []).push([ + "/_error", + function () { + return __webpack_require__(67); + } + ]); + if(false) {} + + +/***/ }) + +}, +/******/ function(__webpack_require__) { // webpackRuntimeModules +/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } +/******/ __webpack_require__.O(0, [888,774,179], function() { return __webpack_exec__(4977); }); +/******/ var __webpack_exports__ = __webpack_require__.O(); +/******/ _N_E = __webpack_exports__; +/******/ } +]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js new file mode 100644 index 000000000000..b57bd572a854 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js @@ -0,0 +1,588 @@ +(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[405],{ + +/***/ 8581: +/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { + + + (window.__NEXT_P = window.__NEXT_P || []).push([ + "/", + function () { + return __webpack_require__(4369); + } + ]); + if(false) {} + + +/***/ }), + +/***/ 7645: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +var __webpack_unused_export__; + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} +function _objectSpread(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } + return target; +} +__webpack_unused_export__ = ({ + value: true +}); +exports["default"] = dynamic; +__webpack_unused_export__ = noSSR; +var _react = _interopRequireDefault(__webpack_require__(7294)); +var _loadable = _interopRequireDefault(__webpack_require__(4588)); +function dynamic(dynamicOptions, options) { + var loadableFn = _loadable.default; + var loadableOptions = { + // A loading component is not required, so we default it + loading: function(param) { + var error = param.error, isLoading = param.isLoading, pastDelay = param.pastDelay; + if (!pastDelay) return null; + if (false) {} + return null; + } + }; + // Support for direct import(), eg: dynamic(import('../hello-world')) + // Note that this is only kept for the edge case where someone is passing in a promise as first argument + // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world')) + // To make sure we don't execute the import without rendering first + if (_instanceof(dynamicOptions, Promise)) { + loadableOptions.loader = function() { + return dynamicOptions; + }; + // Support for having import as a function, eg: dynamic(() => import('../hello-world')) + } else if (typeof dynamicOptions === 'function') { + loadableOptions.loader = dynamicOptions; + // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')}) + } else if (typeof dynamicOptions === 'object') { + loadableOptions = _objectSpread({}, loadableOptions, dynamicOptions); + } + // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () =>

Loading something

}) + loadableOptions = _objectSpread({}, loadableOptions, options); + var suspenseOptions = loadableOptions; + // Error if Fizz rendering is not enabled and `suspense` option is set to true + if ( true && suspenseOptions.suspense) { + throw new Error("Invalid suspense option usage in next/dynamic. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense"); + } + if (suspenseOptions.suspense) { + return loadableFn(suspenseOptions); + } + // coming from build/babel/plugins/react-loadable-plugin.js + if (loadableOptions.loadableGenerated) { + loadableOptions = _objectSpread({}, loadableOptions, loadableOptions.loadableGenerated); + delete loadableOptions.loadableGenerated; + } + // support for disabling server side rendering, eg: dynamic(import('../hello-world'), {ssr: false}) + if (typeof loadableOptions.ssr === 'boolean') { + if (!loadableOptions.ssr) { + delete loadableOptions.ssr; + return noSSR(loadableFn, loadableOptions); + } + delete loadableOptions.ssr; + } + return loadableFn(loadableOptions); +} +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} +var isServerSide = "object" === 'undefined'; +function noSSR(LoadableInitializer, loadableOptions) { + // Removing webpack and modules means react-loadable won't try preloading + delete loadableOptions.webpack; + delete loadableOptions.modules; + // This check is necessary to prevent react-loadable from initializing on the server + if (!isServerSide) { + return LoadableInitializer(loadableOptions); + } + var Loading = loadableOptions.loading; + // This will only be rendered on the server side + return function() { + return /*#__PURE__*/ _react.default.createElement(Loading, { + error: null, + isLoading: true, + pastDelay: false, + timedOut: false + }); + }; +} //# sourceMappingURL=dynamic.js.map + + +/***/ }), + +/***/ 3644: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports.LoadableContext = void 0; +var _react = _interopRequireDefault(__webpack_require__(7294)); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} +var LoadableContext = _react.default.createContext(null); +exports.LoadableContext = LoadableContext; +if (false) {} //# sourceMappingURL=loadable-context.js.map + + +/***/ }), + +/***/ 4588: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for(var i = 0; i < props.length; i++){ + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _objectSpread(target) { + for(var i = 1; i < arguments.length; i++){ + var source = arguments[i] != null ? arguments[i] : {}; + var ownKeys = Object.keys(source); + if (typeof Object.getOwnPropertySymbols === "function") { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + ownKeys.forEach(function(key) { + _defineProperty(target, key, source[key]); + }); + } + return target; +} +Object.defineProperty(exports, "__esModule", ({ + value: true +})); +exports["default"] = void 0; +var _react = _interopRequireDefault(__webpack_require__(7294)); +var _useSubscription = __webpack_require__(7161); +var _loadableContext = __webpack_require__(3644); +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} +var ALL_INITIALIZERS = []; +var READY_INITIALIZERS = []; +var initialized = false; +function load(loader) { + var promise = loader(); + var state = { + loading: true, + loaded: null, + error: null + }; + state.promise = promise.then(function(loaded) { + state.loading = false; + state.loaded = loaded; + return loaded; + }).catch(function(err) { + state.loading = false; + state.error = err; + throw err; + }); + return state; +} +function resolve(obj) { + return obj && obj.__esModule ? obj.default : obj; +} +function createLoadableComponent(loadFn, options) { + var init = function init() { + if (!subscription) { + var sub = new LoadableSubscription(loadFn, opts); + subscription = { + getCurrentValue: sub.getCurrentValue.bind(sub), + subscribe: sub.subscribe.bind(sub), + retry: sub.retry.bind(sub), + promise: sub.promise.bind(sub) + }; + } + return subscription.promise(); + }; + var LoadableImpl = function LoadableImpl(props, ref) { + init(); + var context = _react.default.useContext(_loadableContext.LoadableContext); + var state = (0, _useSubscription).useSubscription(subscription); + _react.default.useImperativeHandle(ref, function() { + return { + retry: subscription.retry + }; + }, []); + if (context && Array.isArray(opts.modules)) { + opts.modules.forEach(function(moduleName) { + context(moduleName); + }); + } + return _react.default.useMemo(function() { + if (state.loading || state.error) { + return _react.default.createElement(opts.loading, { + isLoading: state.loading, + pastDelay: state.pastDelay, + timedOut: state.timedOut, + error: state.error, + retry: subscription.retry + }); + } else if (state.loaded) { + return _react.default.createElement(resolve(state.loaded), props); + } else { + return null; + } + }, [ + props, + state + ]); + }; + var LazyImpl = function LazyImpl(props, ref) { + return _react.default.createElement(opts.lazy, _objectSpread({}, props, { + ref: ref + })); + }; + var opts = Object.assign({ + loader: null, + loading: null, + delay: 200, + timeout: null, + webpack: null, + modules: null, + suspense: false + }, options); + if (opts.suspense) { + opts.lazy = _react.default.lazy(opts.loader); + } + var subscription = null; + // Server only + if (false) {} + // Client only + if (!initialized && "object" !== 'undefined' && !opts.suspense) { + // require.resolveWeak check is needed for environments that don't have it available like Jest + var moduleIds = opts.webpack && "function" === 'function' ? opts.webpack() : opts.modules; + if (moduleIds) { + READY_INITIALIZERS.push(function(ids) { + var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined; + try { + for(var _iterator = moduleIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){ + var moduleId = _step.value; + if (ids.indexOf(moduleId) !== -1) { + return init(); + } + } + } catch (err) { + _didIteratorError = true; + _iteratorError = err; + } finally{ + try { + if (!_iteratorNormalCompletion && _iterator.return != null) { + _iterator.return(); + } + } finally{ + if (_didIteratorError) { + throw _iteratorError; + } + } + } + }); + } + } + var LoadableComponent = opts.suspense ? LazyImpl : LoadableImpl; + LoadableComponent.preload = function() { + return !opts.suspense && init(); + }; + LoadableComponent.displayName = 'LoadableComponent'; + return _react.default.forwardRef(LoadableComponent); +} +var LoadableSubscription = /*#__PURE__*/ function() { + function LoadableSubscription(loadFn, opts) { + _classCallCheck(this, LoadableSubscription); + this._loadFn = loadFn; + this._opts = opts; + this._callbacks = new Set(); + this._delay = null; + this._timeout = null; + this.retry(); + } + _createClass(LoadableSubscription, [ + { + key: "promise", + value: function promise() { + return this._res.promise; + } + }, + { + key: "retry", + value: function retry() { + var _this = this; + this._clearTimeouts(); + this._res = this._loadFn(this._opts.loader); + this._state = { + pastDelay: false, + timedOut: false + }; + var ref = this, res = ref._res, opts = ref._opts; + if (res.loading) { + if (typeof opts.delay === 'number') { + if (opts.delay === 0) { + this._state.pastDelay = true; + } else { + var _this1 = this; + this._delay = setTimeout(function() { + _this1._update({ + pastDelay: true + }); + }, opts.delay); + } + } + if (typeof opts.timeout === 'number') { + var _this2 = this; + this._timeout = setTimeout(function() { + _this2._update({ + timedOut: true + }); + }, opts.timeout); + } + } + this._res.promise.then(function() { + _this._update({}); + _this._clearTimeouts(); + }).catch(function(_err) { + _this._update({}); + _this._clearTimeouts(); + }); + this._update({}); + } + }, + { + key: "_update", + value: function _update(partial) { + this._state = _objectSpread({}, this._state, { + error: this._res.error, + loaded: this._res.loaded, + loading: this._res.loading + }, partial); + this._callbacks.forEach(function(callback) { + return callback(); + }); + } + }, + { + key: "_clearTimeouts", + value: function _clearTimeouts() { + clearTimeout(this._delay); + clearTimeout(this._timeout); + } + }, + { + key: "getCurrentValue", + value: function getCurrentValue() { + return this._state; + } + }, + { + key: "subscribe", + value: function subscribe(callback) { + var _this = this; + this._callbacks.add(callback); + return function() { + _this._callbacks.delete(callback); + }; + } + } + ]); + return LoadableSubscription; +}(); +function Loadable(opts) { + return createLoadableComponent(load, opts); +} +function flushInitializers(initializers, ids) { + var promises = []; + while(initializers.length){ + var init = initializers.pop(); + promises.push(init(ids)); + } + return Promise.all(promises).then(function() { + if (initializers.length) { + return flushInitializers(initializers, ids); + } + }); +} +Loadable.preloadAll = function() { + return new Promise(function(resolveInitializers, reject) { + flushInitializers(ALL_INITIALIZERS).then(resolveInitializers, reject); + }); +}; +Loadable.preloadReady = function() { + var ids = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; + return new Promise(function(resolvePreload) { + var res = function() { + initialized = true; + return resolvePreload(); + }; + // We always will resolve, errors should be handled within loading UIs. + flushInitializers(READY_INITIALIZERS, ids).then(res, res); + }); +}; +if (true) { + window.__NEXT_PRELOADREADY = Loadable.preloadReady; +} +var _default = Loadable; +exports["default"] = _default; //# sourceMappingURL=loadable.js.map + + +/***/ }), + +/***/ 4369: +/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export */ __webpack_require__.d(__webpack_exports__, { +/* harmony export */ "default": function() { return /* binding */ Index; } +/* harmony export */ }); +/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5893); +/* harmony import */ var next_dynamic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5152); + + +var Ace = (0,next_dynamic__WEBPACK_IMPORTED_MODULE_1__["default"])(function() { + return Promise.all(/* import() */[__webpack_require__.e(281), __webpack_require__.e(981)]).then(__webpack_require__.bind(__webpack_require__, 4981)); +}, { + loadableGenerated: { + webpack: function() { + return [ + /*require.resolve*/(4981) + ]; + } + }, + loading: function() { + return /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", { + children: "Loading..." + }); + }, + ssr: false +}); +function Index() { + return /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)("main", { + children: [ + /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("h1", { + children: "Code editor" + }), + /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(Ace, {}) + ] + }); +}; + + +/***/ }), + +/***/ 5152: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +module.exports = __webpack_require__(7645) + + +/***/ }), + +/***/ 8217: +/***/ (function(__unused_webpack_module, exports, __webpack_require__) { + +"use strict"; +/** @license React vundefined + * use-subscription.production.min.js + * + * Copyright (c) Facebook, Inc. and its affiliates. + * + * This source code is licensed under the MIT license found in the + * LICENSE file in the root directory of this source tree. + */ +var e=__webpack_require__(6086),g=__webpack_require__(7294); +exports.useSubscription=function(a){var c=a.getCurrentValue,d=a.subscribe,b=g.useState(function(){return{getCurrentValue:c,subscribe:d,value:c()}});a=b[0];var f=b[1];b=a.value;if(a.getCurrentValue!==c||a.subscribe!==d)b=c(),f({getCurrentValue:c,subscribe:d,value:b});g.useDebugValue(b);g.useEffect(function(){function b(){if(!a){var b=c();f(function(a){return a.getCurrentValue!==c||a.subscribe!==d||a.value===b?a:e({},a,{value:b})})}}var a=!1,h=d(b);b();return function(){a=!0;h()}},[c,d]);return b}; + + +/***/ }), + +/***/ 7161: +/***/ (function(module, __unused_webpack_exports, __webpack_require__) { + +"use strict"; + + +if (true) { + module.exports = __webpack_require__(8217); +} else {} + + +/***/ }) + +}, +/******/ function(__webpack_require__) { // webpackRuntimeModules +/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } +/******/ __webpack_require__.O(0, [774,888,179], function() { return __webpack_exec__(8581); }); +/******/ var __webpack_exports__ = __webpack_require__.O(); +/******/ _N_E = __webpack_exports__; +/******/ } +]); \ No newline at end of file From 6cac635717202fc5d40ba5f39f8205f86addf1dc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 29 Mar 2022 18:31:56 +0900 Subject: [PATCH 2/5] Rename --- .../analysis-snapshot.rust-debug | 193358 +++++++++++++++ .../chunks/8a28b14e.d8fbda268ed281a1/input.js | 0 .../analysis-snapshot.rust-debug | 52684 ++++ .../chunks/981.ed660b563826161d/input.js | 0 .../analysis-snapshot.rust-debug | 4344 + .../pages/_app-6982cbb7db4140a2/input.js | 0 .../analysis-snapshot.rust-debug | 388 + .../pages/_error-04f03cfa2a163874/input.js | 0 .../analysis-snapshot.rust-debug | 7664 + .../pages/index-665b680df96552be/input.js | 0 10 files changed, 258438 insertions(+) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/analysis-snapshot.rust-debug rename crates/swc_ecma_minifier/tests/compress/fixture/next/{raw/static => react-ace}/chunks/8a28b14e.d8fbda268ed281a1/input.js (100%) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug rename crates/swc_ecma_minifier/tests/compress/fixture/next/{raw/static => react-ace}/chunks/981.ed660b563826161d/input.js (100%) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug rename crates/swc_ecma_minifier/tests/compress/fixture/next/{raw/static => react-ace}/chunks/pages/_app-6982cbb7db4140a2/input.js (100%) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug rename crates/swc_ecma_minifier/tests/compress/fixture/next/{raw/static => react-ace}/chunks/pages/_error-04f03cfa2a163874/input.js (100%) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug rename crates/swc_ecma_minifier/tests/compress/fixture/next/{raw/static => react-ace}/chunks/pages/index-665b680df96552be/input.js (100%) diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/analysis-snapshot.rust-debug new file mode 100644 index 000000000000..9a0566d3dafa --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/analysis-snapshot.rust-debug @@ -0,0 +1,193358 @@ +TestSnapshot { + vars: [ + ( + ( + Atom('$blockChangeEvents' type=dynamic), + #1326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$byLines' type=dynamic), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$cancelT' type=dynamic), + #126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$disableFakeMultiline' type=dynamic), + #744, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$getTransformedPoint' type=dynamic), + #471, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$isPlaceholder' type=dynamic), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$pointsInOrder' type=dynamic), + #471, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$printMargin' type=dynamic), + #699, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$updateMarkers' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$viewMargin' type=dynamic), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('$workerBlob' type=dynamic), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ACE_NAMESPACE' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('AL' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('AN' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('AUTOSCROLL_DELAY' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Anchor' type=inline), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Anchor' type=inline), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('AppConfig' type=dynamic), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('AppConfig' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ArabicAlefBetIntervalsBegine' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ArabicAlefBetIntervalsEnd' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Array' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 37, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 37, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('B' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 11, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BN' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 61, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 61, + usage_count: 61, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BROKEN_SETDATA' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BackgroundTokenizer' type=dynamic), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BackgroundTokenizer' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Behaviour' type=dynamic), + #410, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Behaviour' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BidiHandler' type=dynamic), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BidiHandler' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Blob' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BlobBuilder' type=dynamic), + #1265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Boolean' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('BracketMatch' type=dynamic), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CHAR' type=inline), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CHAR_COUNT' type=dynamic), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CHAR_EXT' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CS' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CommandManager' type=dynamic), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CommandManager' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CstyleBehaviour' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 27, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 27, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CstyleBehaviour' type=dynamic), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Cursor' type=inline), + #1127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('CursorLayer' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DRAG_OFFSET' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Date' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DefaultGutterHandler' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DefaultHandlers' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DefaultHandlers' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Document' type=static), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Document' type=static), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DragdropHandler' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DragdropHandler' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EN' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 26, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 26, + usage_count: 26, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EOL_CHAR' type=dynamic), + #1105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ES' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ET' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 17, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EditSession' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EditSession' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EditSession' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EditSession' type=dynamic), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Editor' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Editor' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Editor' type=inline), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Element' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Error' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventListener' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Fold' type=inline), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Fold' type=inline), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FoldHandler' type=dynamic), + #302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FoldHandler' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FoldLine' type=dynamic), + #531, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FoldLine' type=dynamic), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FoldMode' type=dynamic), + #1370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Folding' type=inline), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FontMetrics' type=dynamic), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FontMetrics' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Gutter' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('GutterHandler' type=dynamic), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('GutterLayer' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('GutterTooltip' type=dynamic), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HAS_FOCUS_ARGS' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HIDE_TEXTAREA' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HScrollBar' type=dynamic), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HScrollBar' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HashHandler' type=dynamic), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HashHandler' type=dynamic), + #1309, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HighlightRules' type=dynamic), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Infinity' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 29, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 30, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('KEYS' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('KEY_MODS' type=dynamic), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('KeyBinding' type=dynamic), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('KeyBinding' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Keys' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('L' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 60, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 60, + usage_count: 60, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('L' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LRE' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LRO' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LTR' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LineWidgets' type=dynamic), + #1377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LineWidgets' type=dynamic), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Lines' type=inline), + #1055, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Lines' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Lines' type=inline), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MAX' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MAX_LINE_LENGTH' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MAX_SCROLL_H' type=dynamic), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MAX_TOKEN_COUNT' type=dynamic), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MODS' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Main' type=inline), + #1288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Marker' type=inline), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MarkerLayer' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Math' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 126, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 16, + mutation_by_call_count: 0, + usage_count: 128, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Mode' type=inline), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Mode' type=inline), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MouseEvent' type=static), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MouseEvent' type=static), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MouseEvent' type=static), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MouseHandler' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MouseHandler' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MultiHashHandler' type=dynamic), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MultiHashHandler' type=dynamic), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MultiSelect' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('NSM' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Number' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ON' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 119, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 119, + usage_count: 119, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Object' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 24, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 24, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PDF' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PLACEHOLDER_BODY' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PLACEHOLDER_START' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PUNCTUATION' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PlaceHolder' type=dynamic), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Promise' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('R' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RLE' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RLO' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RTL' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #416, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #531, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Range' type=static), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RangeList' type=dynamic), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RangeList' type=dynamic), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RangeList' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RegExp' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 10, + usage_count: 21, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RenderLoop' type=dynamic), + #1156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RenderLoop' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Renderer' type=dynamic), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ResizeObserver' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('S' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SAFE_INSERT_BEFORE_TOKENS' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SAFE_INSERT_IN_TOKENS' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SCROLL_COOLDOWN_T' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SCROLL_CURSOR_DELAY' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SCROLL_CURSOR_HYSTERESIS' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SPACE' type=inline), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ScrollBar' type=dynamic), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Search' type=inline), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Search' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Search' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SearchHighlight' type=dynamic), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SearchHighlight' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Selection' type=static), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Selection' type=static), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Selection' type=static), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('String' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TAB' type=inline), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TAB_SPACE' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Text' type=static), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextHighlightRules' type=dynamic), + #396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextHighlightRules' type=dynamic), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextInput' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextInput' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextLayer' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TextMode' type=dynamic), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #416, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TokenIterator' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Tokenizer' type=dynamic), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Tokenizer' type=dynamic), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Tooltip' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Tooltip' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('UIWorkerClient' type=dynamic), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('URL' type=static), + #1267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('USE_IE_MIME_TYPE' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('USE_OBSERVER' type=dynamic), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('UndoManager' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('UndoManager' type=dynamic), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('UnicodeTBL00' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('UnicodeTBL20' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('VScrollBar' type=dynamic), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('VScrollBar' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('VirtualRenderer' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('WS' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 17, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Worker' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('WorkerClient' type=dynamic), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('XHTML_NS' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('XMLHttpRequest' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_' type=inline), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_' type=inline), + #899, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_' type=inline), + #1404, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_array' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_computeLevels' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_getCharClass' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_getCharacterType' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_id' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_invertLevel' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_isArabicDiacritics' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_isIOS' type=inline), + #168, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_isMobile' type=dynamic), + #168, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_navigator' type=dynamic), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_numberRx' type=dynamic), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_require' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #899, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #903, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #918, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 20, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1293, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_self' type=inline), + #1298, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #106, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #247, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #537, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #553, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #583, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #964, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #1178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #1179, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #1180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #1408, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('aLength' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('accel' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 71, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 71, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #229, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #411, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #412, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('action' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('activeListenerOptions' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('add' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('add' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addAltCursorListeners' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addDragMarker' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addIosSelectionHandler' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addListener' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 14, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addRules' type=dynamic), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addSplit' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addTokens' type=dynamic), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addTouchListeners' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('addWordBoundary' type=dynamic), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('added' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('additive' type=dynamic), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('adjustedregex' type=dynamic), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('after' type=inline), + #448, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('after' type=inline), + #1031, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('after' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('after' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('afterContextMenu' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('afterLoad' type=dynamic), + #281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('afterLoad' type=dynamic), + #1241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('afterStart' type=dynamic), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alignLeft' type=dynamic), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alignRight' type=dynamic), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alignment' type=dynamic), + #1223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('all' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('allowMerge' type=dynamic), + #1028, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alt' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('altCursor' type=dynamic), + #1365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('altDown' type=inline), + #1366, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alwaysVisible' type=dynamic), + #1208, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('alwaysVisible' type=dynamic), + #1209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('amount' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ancestors' type=dynamic), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #568, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #569, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #570, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #571, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1292, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1294, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchor' type=inline), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchorColumn' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchorPos' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anchorRow' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('anim' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #983, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #988, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #997, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #998, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #999, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #1000, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animate' type=inline), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animationSteps' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('animationTimer' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annoText' type=dynamic), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotation' type=dynamic), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotation' type=dynamic), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotation' type=dynamic), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotation' type=dynamic), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #655, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #1219, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appName' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('append' type=inline), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('append' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('applyComposition' type=dynamic), + #934, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('applyDelta' type=dynamic), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #522, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #618, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #782, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #818, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #822, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #828, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #834, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #852, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #882, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #931, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #1072, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #1274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #1275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arguments' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arr' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arr' type=inline), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arr' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arr' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrow' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('attr' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('attributes' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('autoScroll' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('autoScrollStartTime' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('availableWidth' type=dynamic), + #1193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ax' type=inline), + #181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ax' type=inline), + #224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ay' type=inline), + #181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ay' type=inline), + #224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #537, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #553, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #583, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #703, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #964, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #1178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #1179, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #1180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bColIsAfter' type=dynamic), + #473, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('backwards' type=dynamic), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('base' type=inline), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('base' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('before' type=inline), + #448, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('before' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('before' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('before' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('before' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('beforeCursor' type=dynamic), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('behaviours' type=dynamic), + #412, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('behaviours' type=dynamic), + #414, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('behaviours' type=dynamic), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bidiCharWidth' type=dynamic), + #336, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bidiLevels' type=dynamic), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bidiRE' type=inline), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bidiUtil' type=dynamic), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('binarySearch' type=dynamic), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bindKey' type=inline), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 87, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 87, + usage_count: 87, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('binding' type=inline), + #763, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('binding' type=inline), + #764, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bl' type=inline), + #1095, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blink' type=inline), + #1138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blinkInterval' type=dynamic), + #1134, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blinking' type=dynamic), + #1133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blob' type=inline), + #1267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blobBuilder' type=dynamic), + #1265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blobURL' type=inline), + #1267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blockSelect' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('body' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('boldSize' type=dynamic), + #1164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bottom' type=inline), + #1206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bottom' type=inline), + #1207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bottomMargin' type=dynamic), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('br' type=inline), + #1095, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #435, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #436, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #437, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracket' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracketPos' type=dynamic), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracketPos' type=dynamic), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracketPos' type=dynamic), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bracketType' type=dynamic), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('brackets' type=dynamic), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('breakpoints' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bringToFront' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('buf' type=inline), + #1345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('buildDom' type=dynamic), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('button' type=inline), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('button' type=inline), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('button' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bx' type=inline), + #181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bx' type=inline), + #224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('by' type=inline), + #181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('by' type=inline), + #224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #710, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #727, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #728, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 65, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 65, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #755, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c1' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 28, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 12, + usage_count: 28, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cType' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cache' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cache' type=inline), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cacheArray' type=dynamic), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('calcDistance' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('calcDistance' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('calcRangeOrientation' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #78, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #411, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #749, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #750, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #983, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #1006, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #1271, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #1275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callbackId' type=dynamic), + #1286, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callbackName' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canAccept' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canScroll' type=dynamic), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cancelComposition' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canvasHeight' type=dynamic), + #1056, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canvasPos' type=dynamic), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canvasPos' type=dynamic), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('canvasPos' type=dynamic), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('capturing' type=dynamic), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #142, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #662, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #903, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #908, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #1168, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cb' type=inline), + #1241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1062, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1063, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1064, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1076, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cell' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cells' type=inline), + #1076, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('center' type=inline), + #983, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('center' type=inline), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #322, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #323, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #708, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #1171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ch' type=inline), + #1172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chain' type=inline), + #763, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('change' type=inline), + #1159, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('change' type=inline), + #1160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changedWidgets' type=dynamic), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1158, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 35, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 34, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charBefore' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charBeforeCursor' type=dynamic), + #621, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charCount' type=dynamic), + #1215, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charRange' type=dynamic), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charTypes' type=dynamic), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charWidth' type=dynamic), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('character' type=dynamic), + #291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('characterWidth' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('characterWidth' type=dynamic), + #336, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('childIndex' type=dynamic), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chr' type=inline), + #621, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chr' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chr' type=inline), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chr' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chr' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chunk' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chunks' type=inline), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cjk' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cjkSpace' type=dynamic), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ckb' type=inline), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ckb' type=inline), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #188, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #644, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #645, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #647, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1069, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1070, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1092, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1217, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #1299, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classes' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classname' type=dynamic), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('classname' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #527, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #654, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clazz' type=inline), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clearDragMarker' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clearInterval' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clearTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 14, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clickCount' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clickCount' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clicks' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clientPos' type=dynamic), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clipboard' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clipboard' type=dynamic), + #227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clipboard' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clipboardData' type=dynamic), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clipped' type=inline), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cloneDelta' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cloneFolds' type=dynamic), + #589, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clonePos' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('closeTimeout' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('closing' type=inline), + #423, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('closing' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('closingBracket' type=dynamic), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmd' type=inline), + #1274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmd' type=inline), + #1275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmd' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmdGroup' type=dynamic), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmdResult' type=dynamic), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #87, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #540, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 17, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmp2' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmpEnd' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmpEnd' type=inline), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmpStart' type=dynamic), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cmpStart' type=dynamic), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('code' type=inline), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #729, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('col' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('colDiff' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('colDiff' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('colShift' type=dynamic), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('collDiff' type=dynamic), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cols' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #83, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #88, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #89, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #90, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #91, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #92, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #93, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #94, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #95, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #97, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #98, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #358, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #366, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #419, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #420, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #470, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #475, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #477, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #481, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #496, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #498, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #500, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #540, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #554, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #601, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #658, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #694, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #695, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #710, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #727, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #957, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #985, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #988, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #989, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1240, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('column' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #760, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #762, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #765, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #768, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #773, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #782, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #931, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #1343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commandEvent' type=dynamic), + #900, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commandMode' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commandName' type=dynamic), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #767, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #769, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #780, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comment' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comment' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commentWithSpace' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comparator' type=dynamic), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comparePoints' type=dynamic), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comparePoints' type=dynamic), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('comparePoints' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('completionKeywords' type=dynamic), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('component' type=dynamic), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('composition' type=dynamic), + #934, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('composition' type=dynamic), + #935, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('composition' type=dynamic), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('composition' type=dynamic), + #1236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('compositionState' type=dynamic), + #977, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cond' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('condPos' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #757, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #758, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1003, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1022, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1057, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1060, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1077, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 8, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 9, + usage_count: 22, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1140, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 28, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 20, + usage_count: 27, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('config' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('console' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 27, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 27, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('consumePoint' type=dynamic), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('consumeRange' type=dynamic), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('consumedFolds' type=dynamic), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('container' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('container' type=dynamic), + #898, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('container' type=dynamic), + #1183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('containerEl' type=dynamic), + #1202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('context' type=inline), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 32, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 30, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('contextCache' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('contextMenu' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('controlCharacter' type=dynamic), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copied' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #111, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #974, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copy' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copyAllowed' type=dynamic), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copyLine' type=dynamic), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('copyModifierState' type=dynamic), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count' type=inline), + #108, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('counter' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('createContextMenu' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('createWorker' type=dynamic), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('css' type=inline), + #1092, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cssCache' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cssText' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ctor' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ctrl' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('curLength' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('curLine' type=inline), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('curOp' type=inline), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('curr' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currIndent' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currWordStart' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentDocument' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentIndex' type=dynamic), + #332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentLine' type=dynamic), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentScript' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentState' type=dynamic), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentState' type=dynamic), + #400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentState' type=dynamic), + #401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentState' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentTag' type=dynamic), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #341, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #358, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #359, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #362, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #433, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #435, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #436, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #437, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #438, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #893, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 20, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #956, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #957, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #966, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorColumn' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorIndex' type=dynamic), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorLayer' type=dynamic), + #1005, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorLeft' type=dynamic), + #1139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorMovedTime' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorPointOnCaretMoved' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorPos' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorPos' type=dynamic), + #906, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorRow' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorStyle' type=dynamic), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorStyle' type=dynamic), + #1246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorTop' type=dynamic), + #1139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursors' type=inline), + #1129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursors' type=inline), + #1130, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cutLine' type=inline), + #851, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #1044, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #1045, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 16, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #1355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d1' type=inline), + #1047, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d1' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 34, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 16, + usage_count: 33, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d1' type=inline), + #1050, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d2' type=inline), + #1047, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d2' type=inline), + #1050, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #144, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #147, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #153, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #268, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #313, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #380, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #382, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #383, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #520, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #525, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #617, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #778, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #1276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #1286, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #1287, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dataTransfer' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dataTransfer' type=dynamic), + #210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dataTransfer' type=dynamic), + #214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deHyphenate' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('decimals' type=dynamic), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('decorations' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deepCopy' type=dynamic), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultCommands' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultHandler' type=dynamic), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultHandler' type=dynamic), + #458, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultHandler' type=dynamic), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultQuotes' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultTimeout' type=dynamic), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultToken' type=dynamic), + #406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deferred' type=dynamic), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('define' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delay' type=inline), + #77, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delegations' type=dynamic), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deleteFirstNewLine' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deleteLastNewLine' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deleteRange' type=dynamic), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deleteRange' type=dynamic), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deletedLines' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #330, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #465, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #472, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #509, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #510, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #512, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #522, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #618, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #633, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #678, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #679, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #682, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #921, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1028, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1030, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1040, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1072, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1297, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaColShift' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaEnd' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaIsInsert' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaRowShift' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaSet' type=dynamic), + #1035, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaSet' type=dynamic), + #1036, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaSet' type=dynamic), + #1041, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaSet' type=dynamic), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaSets' type=dynamic), + #1054, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaStart' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaX' type=inline), + #1231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaX' type=inline), + #1232, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaY' type=inline), + #1231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltaY' type=inline), + #1232, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #507, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #508, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #678, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #679, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deltas' type=inline), + #1054, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dep' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deps' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('depth' type=inline), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('depth' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('depth' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('depth' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('depth' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('desiredHeight' type=dynamic), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('desiredLimit' type=dynamic), + #699, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('destroyer' type=dynamic), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('destroyer' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('destroyer' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('destroyer' type=dynamic), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('det' type=inline), + #1177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('detectArrowKeys' type=dynamic), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('detectListenerOptionsSupport' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #1036, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff1' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff2' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('digit' type=inline), + #386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1050, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1051, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dir' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('direction' type=dynamic), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('direction' type=dynamic), + #361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('disabled' type=dynamic), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('disabled' type=dynamic), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('display' type=inline), + #946, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('display' type=inline), + #1111, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('display' type=inline), + #1196, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('displayLength' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('distance' type=dynamic), + #176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('distance' type=dynamic), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('distance' type=dynamic), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('distanceFromStart' type=dynamic), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('div' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doCache' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doCache' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doCopy' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doNotValidate' type=dynamic), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doNotValidate' type=dynamic), + #509, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #454, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #470, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #476, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #519, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #629, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #1105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #1278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #1291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('doc' type=inline), + #1407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #715, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #716, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #723, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docColumn' type=dynamic), + #724, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docEnd' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docLength' type=dynamic), + #510, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docLines' type=dynamic), + #466, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docLines' type=dynamic), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docLines' type=dynamic), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docPos' type=inline), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #329, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #579, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #580, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #597, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #598, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #599, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #630, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #715, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #716, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('docRow' type=inline), + #724, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('document' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 39, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 13, + usage_count: 39, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('document' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1055, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 40, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 40, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1376, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dom' type=inline), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('domEvent' type=dynamic), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dontSelect' type=dynamic), + #678, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dontSelect' type=dynamic), + #679, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dontSelect' type=dynamic), + #1035, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dontSelect' type=dynamic), + #1036, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dragCursor' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 10, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dragDelay' type=dynamic), + #939, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dragImage' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dragOperation' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dragSelectionMarker' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dropData' type=dynamic), + #210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dropEffect' type=dynamic), + #206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dropEffect' type=dynamic), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ds1' type=inline), + #1048, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ds2' type=inline), + #1048, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dt' type=inline), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dt' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dt' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dx' type=inline), + #1225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #68, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #69, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #71, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #72, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #74, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #130, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #131, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #134, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #144, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #147, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #148, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #154, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #159, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #165, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #166, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #195, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #196, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #208, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #217, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #229, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #232, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #240, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #268, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #282, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #292, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #293, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #294, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #297, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #298, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #299, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #301, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #305, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #316, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #379, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #615, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #619, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #632, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #661, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #665, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #666, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #745, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #747, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #781, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #782, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #784, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #813, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #841, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #842, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #861, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #902, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #919, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #920, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #922, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #924, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #926, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #928, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #936, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1023, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1108, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1166, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1184, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1185, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1186, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1266, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1271, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1282, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 15, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1305, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1308, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1339, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1340, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1341, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1366, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1382, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ec' type=inline), + #741, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #179, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 40, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 40, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 51, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 51, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 36, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 15, + usage_count: 36, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #303, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #308, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #313, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #341, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #422, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #433, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #435, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #436, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #516, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #778, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #782, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #783, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #785, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #791, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #793, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #795, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #797, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #798, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #799, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #800, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #801, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #802, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #803, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #804, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #805, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #806, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #807, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #808, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #809, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #810, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #811, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #812, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #814, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #815, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #816, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #817, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #818, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #819, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #820, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #821, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #822, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #823, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #824, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #825, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #826, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #827, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #828, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #829, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #830, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #831, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #832, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #833, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #834, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #835, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #836, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #837, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #838, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #839, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #840, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #843, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #844, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #845, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #846, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #847, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #848, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #849, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #850, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #851, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #852, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #853, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #854, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #855, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #856, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #857, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #858, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #859, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #860, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #862, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #863, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #864, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #865, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #866, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #867, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #868, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #869, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #870, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #871, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #872, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #873, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #874, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #875, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #876, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #877, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #878, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #879, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #880, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #881, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #882, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #883, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #884, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #885, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #886, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #887, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #888, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #889, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #892, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #893, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #894, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #895, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #896, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1006, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1023, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1024, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1025, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 30, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 30, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1310, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1311, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1312, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1313, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1314, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1316, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1317, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1322, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1323, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 25, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 25, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1383, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 23, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorCss' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorRect' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('effectAllowed' type=dynamic), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #22, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #63, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #615, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1001, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1020, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 9, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('elPos' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('elem' type=inline), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('elem' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('elem' type=inline), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1056, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1085, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('element' type=inline), + #1173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('elements' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('els' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('embedRules' type=dynamic), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('emitSync' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('enable' type=inline), + #680, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('enable' type=inline), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('enable' type=inline), + #1004, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('enabled' type=inline), + #950, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('enabled' type=inline), + #951, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #99, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #378, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #445, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #495, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #501, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #502, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #503, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #506, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1051, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endCol' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endCol' type=inline), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endCol' type=inline), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #81, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #503, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endColumn' type=dynamic), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endFold' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #549, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endIndex' type=dynamic), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endLine' type=inline), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endOfLine' type=dynamic), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endOffsetX' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endPoint' type=dynamic), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRange' type=dynamic), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRange' type=dynamic), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #81, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #654, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #686, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endW' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('env' type=static), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eolChar' type=inline), + #338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalPointsInOrder' type=dynamic), + #473, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('er' type=inline), + #741, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('err' type=inline), + #1272, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('errorText' type=dynamic), + #465, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('esc' type=inline), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('escapeRules' type=dynamic), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #179, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ev' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 22, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #928, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1300, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventHandler' type=dynamic), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventHandler' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventName' type=dynamic), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventNames' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eventTarget' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ex' type=inline), + #1277, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('excludeEdges' type=dynamic), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('excludeEdges' type=dynamic), + #549, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('excludeLastChar' type=dynamic), + #360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('expand' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('expandInner' type=dynamic), + #595, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exportAce' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 29, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 29, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 38, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 38, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 32, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 32, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 21, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #410, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #416, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #531, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1055, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1309, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1376, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extendLeft' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extendRight' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraLength' type=dynamic), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraLength' type=dynamic), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraStyle' type=dynamic), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('f' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('factor' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('factor' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fade' type=inline), + #953, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fcn' type=inline), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fcn' type=inline), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fd' type=inline), + #603, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('filter' type=inline), + #414, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('filter' type=inline), + #415, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('find' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('findAnnotations' type=dynamic), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('findKeyCommand' type=dynamic), + #776, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('first' type=inline), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('first' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('first' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('first' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('first' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstColumnPosition' type=dynamic), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstCondition' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstConsumed' type=dynamic), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstLineEndCol' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstLineNumber' type=dynamic), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstLineNumber' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRange' type=dynamic), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRange' type=dynamic), + #740, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #99, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #488, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #492, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #520, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #618, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #673, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #677, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 7, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #690, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #691, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #692, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #703, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1072, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1188, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRow' type=dynamic), + #1214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRowHeight' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstRowScreen' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('flag' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('flag' type=inline), + #393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fm' type=inline), + #726, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('focusEditor' type=dynamic), + #289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #362, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #533, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #535, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #536, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 21, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #540, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #545, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #546, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #563, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #564, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 16, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #587, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #590, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #591, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #594, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #605, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #617, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #632, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #1076, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fold' type=inline), + #1392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldBefore' type=dynamic), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #532, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #543, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #579, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #580, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldData' type=dynamic), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldHeight' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldIndex' type=dynamic), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #562, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #579, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #580, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #582, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #598, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #599, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #604, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: true, + declared: true, + declared_count: 5, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 21, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLine' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLineBefore' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLineNext' type=dynamic), + #543, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLineNext' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLines' type=dynamic), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLines' type=dynamic), + #577, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLines' type=dynamic), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldLines' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldMode' type=dynamic), + #613, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStart' type=dynamic), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStartRow' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStyle' type=dynamic), + #1371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldStyle' type=dynamic), + #1372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldWidget' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldWidget' type=dynamic), + #1085, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldWidgets' type=dynamic), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foldWidgets' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #532, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #543, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #575, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #577, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #586, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #589, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #593, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #595, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #604, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('folds' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fontMetrics' type=dynamic), + #336, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('forEach' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('forEachInLine' type=dynamic), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #907, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #1188, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #1189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('force' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('forceIEMime' type=dynamic), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('forceLeft' type=dynamic), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('found' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('foundFolds' type=dynamic), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fp' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fr' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fragment' type=dynamic), + #1062, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fragment' type=dynamic), + #1063, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fragment' type=dynamic), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fragment' type=dynamic), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #1030, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #1033, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #1034, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('from' type=static), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fromInput' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fromRange' type=dynamic), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fromValue' type=dynamic), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fromValue' type=dynamic), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fun' type=inline), + #449, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #378, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('functionName' type=dynamic), + #458, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fw' type=inline), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fw' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getBorderClass' type=dynamic), + #1088, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getDropEffect' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getListenerOptions' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getModifierHash' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getPosition' type=dynamic), + #759, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getWrapIndent' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getWrapped' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getZoom' type=inline), + #1173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('global' type=static), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('global' type=static), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('guessRange' type=dynamic), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutter' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterAnno' type=dynamic), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterEl' type=dynamic), + #289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterElement' type=dynamic), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterRegion' type=dynamic), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterRegion' type=dynamic), + #305, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterRegion' type=dynamic), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterRenderer' type=dynamic), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterRenderer' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterWidth' type=dynamic), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterWidth' type=dynamic), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterWidth' type=dynamic), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gutterWidth' type=dynamic), + #1192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #310, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #314, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #711, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #1147, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #1223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #1379, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hMovement' type=dynamic), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hScroll' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hScrollChanged' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handleClick' type=dynamic), + #227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handleClipboardData' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handleLongTap' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handler' type=inline), + #76, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handlers' type=dynamic), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('handlers' type=dynamic), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasBlockSep' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasSegSep' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasUBAT_AL' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasUBAT_B' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasUBAT_S' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasUndo' type=inline), + #228, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #316, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #776, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #936, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashId' type=inline), + #1404, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('head' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1148, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('heightChanged' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hi' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hi' type=inline), + #322, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hi' type=inline), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hiLevel' type=inline), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hide' type=inline), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hide' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hideContextMenu' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hideScrollbars' type=dynamic), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hideScrollbars' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hideTooltip' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('highlight' type=dynamic), + #653, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('highlight' type=dynamic), + #923, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('highlightGutterLine' type=dynamic), + #1080, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('horizScroll' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('host' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 69, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 21, + usage_count: 69, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('host' type=inline), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('html' type=inline), + #186, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('html' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('html' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 7, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #311, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #312, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 9, + mutation_by_call_count: 9, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 6, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 28, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 9, + usage_count: 24, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #382, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #383, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #415, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #442, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #443, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #444, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #445, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #446, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #447, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #449, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #450, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #507, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #508, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #540, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #543, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #546, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #550, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #551, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #556, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #577, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #579, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #580, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #589, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #611, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #630, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #646, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #678, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #679, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #707, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #708, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #746, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #782, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 19, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #970, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1030, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1031, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1041, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1048, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1054, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1062, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1063, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1076, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1130, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1295, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1297, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1298, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1301, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1308, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i1' type=inline), + #1047, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i1' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i2' type=inline), + #1047, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i2' type=inline), + #1049, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #422, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #650, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #763, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #764, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #914, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #1038, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('id' type=inline), + #1275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('idx' type=inline), + #546, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('idx' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('idx' type=inline), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ignoreBlankLines' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ignoreCase' type=dynamic), + #406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ignoreCurrent' type=dynamic), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ignoreFocusEvents' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('impTab' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('impTab_LTR' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('impTab_RTL' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('importCssString' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('importScripts' type=dynamic), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inChClass' type=dynamic), + #393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inComposition' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 28, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 9, + usage_count: 24, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #650, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #652, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #654, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inMainRange' type=dynamic), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inSelection' type=dynamic), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inSelection' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inSelection' type=dynamic), + #235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inSelection' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inToken' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('include' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('include' type=inline), + #1243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('includeEmptyLines' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('includeName' type=dynamic), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indent' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indent' type=inline), + #450, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indent' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indentString' type=dynamic), + #686, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indentString' type=dynamic), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indentation' type=dynamic), + #707, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('indentedSoftWrap' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #1061, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #1331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #1337, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #1338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('init' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initContext' type=dynamic), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 12, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initElement' type=dynamic), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialColumn' type=dynamic), + #417, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialRange' type=dynamic), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialRange' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialRow' type=dynamic), + #417, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialScroll' type=dynamic), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inner' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('input' type=inline), + #453, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('input' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('input' type=inline), + #996, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inputHandler' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('insertAtTabStop' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('insertLine' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('insertPendingStyles' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inserted' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 6, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inserted' type=dynamic), + #144, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('interval' type=dynamic), + #218, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('invisibleEl' type=dynamic), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isAbort' type=inline), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isAllSelected' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isBackwards' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isBackwards' type=dynamic), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isCode' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isCut' type=inline), + #147, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFinite' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFocused' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFullLine' type=dynamic), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFullWidth' type=dynamic), + #628, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isIOS' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isInsert' type=dynamic), + #509, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isInsert' type=dynamic), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isInsert' type=dynamic), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isInternal' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isLastRow' type=dynamic), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isLeftAligned' type=dynamic), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isMobile' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isMultiSelect' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isNaN' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isNewClick' type=dynamic), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isNewRow' type=dynamic), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isNewRow' type=dynamic), + #1126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isOpen' type=inline), + #227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isRightAligned' type=dynamic), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isRoot' type=inline), + #1163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isRtl' type=inline), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isRtlDir' type=dynamic), + #341, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSamePoint' type=dynamic), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSamePoint' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSelected' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSelectedPrev' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSlower' type=dynamic), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isTransformed' type=dynamic), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isUndo' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isUserAction' type=dynamic), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isVisible' type=dynamic), + #1145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isWordAfter' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isWordBefore' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('itLength' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('item' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('item' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('item' type=inline), + #970, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iter' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #433, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #740, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator' type=static), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iterator2' type=dynamic), + #433, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ix' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ix' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #577, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 1, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #1048, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #1054, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('kb' type=inline), + #309, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('kb' type=inline), + #310, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('kb' type=inline), + #311, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('kb' type=inline), + #312, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('kb' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keepCommand' type=dynamic), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keepDesiredColumn' type=dynamic), + #374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keepDesiredColumn' type=dynamic), + #375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keepOrder' type=dynamic), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #111, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 9, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #263, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #270, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #272, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #277, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #412, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #762, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #772, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #776, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #1408, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 11, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #316, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyCode' type=inline), + #936, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyId' type=inline), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyId' type=inline), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyList' type=inline), + #771, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyPart' type=inline), + #763, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyPart' type=inline), + #764, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #316, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #776, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #777, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyString' type=dynamic), + #1404, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyUtil' type=inline), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyUtil' type=inline), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyboardHandler' type=dynamic), + #903, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keys' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keys' type=inline), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keywords' type=dynamic), + #406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keywords' type=dynamic), + #462, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #490, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #630, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #1175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l' type=inline), + #1355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l1' type=inline), + #1177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('l2' type=inline), + #1177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('language' type=dynamic), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #532, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastArabic' type=dynamic), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastCapture' type=dynamic), + #393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastColumn' type=dynamic), + #601, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastColumn' type=dynamic), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastColumn' type=dynamic), + #1126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastDefaultPrevented' type=dynamic), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastDocSplit' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastEnd' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastFold' type=dynamic), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastFoldEndColumn' type=dynamic), + #546, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastIndex' type=dynamic), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastKeyDownKeyCode' type=dynamic), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastLineEl' type=dynamic), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastLineNumber' type=dynamic), + #1022, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastLineText' type=dynamic), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRange' type=dynamic), + #1331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRange' type=dynamic), + #1333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRange' type=dynamic), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRestoreEnd' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #99, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #488, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #492, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #520, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #673, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #677, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #690, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #691, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #692, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #703, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #921, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1077, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1188, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastRow' type=inline), + #1214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastSelectionEnd' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 9, + mutation_by_call_count: 15, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastSelectionStart' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 8, + mutation_by_call_count: 14, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastSplit' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastT' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastValue' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 7, + mutation_by_call_count: 3, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('layerConfig' type=dynamic), + #1094, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('layerConfig' type=dynamic), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('layerConfig' type=dynamic), + #1214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #353, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #1220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lead' type=inline), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leadingSpace' type=dynamic), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leftBoundary' type=dynamic), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leftChar' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leftOfCursor' type=dynamic), + #368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leftOfCursor' type=dynamic), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('leftOffset' type=dynamic), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #480, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #522, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #618, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #695, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #696, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #697, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #708, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #1072, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('len' type=inline), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #496, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #499, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lengthDiff' type=dynamic), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lev' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('level' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('level' type=inline), + #609, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('level' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levels' type=inline), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('limit' type=inline), + #701, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('limit' type=inline), + #1193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('limits' type=inline), + #699, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #435, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #436, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #437, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #438, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #442, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #443, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #444, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #445, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #446, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #447, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #448, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #450, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #452, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #453, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #455, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #496, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #525, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #658, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #799, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #957, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #983, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1357, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineCommentEnd' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineCommentStart' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineCount' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineDif' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineEl' type=inline), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineEl' type=inline), + #1119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineEl' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineElement' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineElements' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineElementsIdx' type=dynamic), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineEnd' type=inline), + #365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineHeight' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineHeight' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineIndent' type=dynamic), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineIndent' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineMode' type=dynamic), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineNumber' type=dynamic), + #988, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineRange' type=dynamic), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineState' type=dynamic), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineTop' type=inline), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineWidgets' type=dynamic), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #490, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #491, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #500, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #501, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #1116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #550, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('list' type=inline), + #1395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listener' type=dynamic), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #283, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listeners' type=dynamic), + #293, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lo' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('location' type=dynamic), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('location' type=dynamic), + #595, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 10, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('logIdx' type=inline), + #326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('logIdx' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('logicalFromVisual' type=dynamic), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('logicalIdx' type=dynamic), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('logicalIdx' type=dynamic), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longTouchTimer' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longestLine' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longestScreenLine' type=dynamic), + #671, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lookup' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('low' type=inline), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lr' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #287, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #388, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #443, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #445, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #663, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #787, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #1357, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #1359, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #1360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #1361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m1' type=inline), + #287, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m1' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m2' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mac' type=inline), + #790, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('main' type=static), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mainClass' type=dynamic), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapping' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapping' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapping' type=inline), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('marker' type=inline), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('marker' type=inline), + #650, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('marker' type=inline), + #651, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('marker' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markerId' type=dynamic), + #651, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markerLayer' type=dynamic), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markerList' type=dynamic), + #1338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markerType' type=dynamic), + #913, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #651, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #1091, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #484, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #530, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #621, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #656, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matchAttempts' type=dynamic), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matchTotal' type=dynamic), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matchType' type=dynamic), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matchcount' type=dynamic), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matched' type=inline), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matches' type=inline), + #119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matches' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matches' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matching' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matching' type=dynamic), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matching' type=dynamic), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('max' type=inline), + #698, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('max' type=inline), + #700, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('max' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('max' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxCol' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxHeight' type=dynamic), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxHeight' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxIndent' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxRow' type=inline), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxRow' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxRow' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxRow' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxScreenColumn' type=dynamic), + #710, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxScreenColumn' type=dynamic), + #727, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxTop' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxTop' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('measure' type=inline), + #1107, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mergeableCommands' type=dynamic), + #902, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('message' type=inline), + #267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('message' type=inline), + #1006, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('message' type=inline), + #1019, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('messageBuffer' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('messageName' type=dynamic), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('method' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mid' type=inline), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mid' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mime' type=inline), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('min' type=inline), + #698, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('min' type=inline), + #700, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('min' type=inline), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('minEmptyLength' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('minHeight' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('minIndent' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('minSpace' type=dynamic), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('minSplit' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mixin' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mixin' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mod' type=inline), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mod' type=inline), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mod' type=inline), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 11, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #414, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #457, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #612, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #627, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #662, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #1407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('modifier' type=dynamic), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('modifier' type=dynamic), + #744, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('modifier' type=dynamic), + #746, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('modifier' type=dynamic), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mods' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #283, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #410, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #416, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #531, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #792, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #794, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #796, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #904, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1007, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1055, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1242, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1309, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1376, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleName' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleName' type=dynamic), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleName' type=dynamic), + #281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleName' type=dynamic), + #1241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleType' type=dynamic), + #281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseEvent' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseEvent' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseEvent' type=dynamic), + #294, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseHandler' type=dynamic), + #170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseHandler' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseHandler' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseMoveHandler' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseTarget' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseTarget' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseTarget' type=dynamic), + #289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseX' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mouseY' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('move' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moveAllowed' type=dynamic), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moveDeltasByOne' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moveIfEqual' type=dynamic), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moveTooltip' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moved' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mover' type=inline), + #353, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('msg' type=inline), + #268, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('msg' type=inline), + #1271, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('msg' type=inline), + #1284, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('msg' type=inline), + #1285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mul' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #1358, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nType' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #22, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #266, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #280, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #292, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #293, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #294, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #411, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #413, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #761, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #768, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #770, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #1257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #1287, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('navigateWithinSoftTabs' type=dynamic), + #642, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('navigator' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nearestXOffset' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nearestYOffset' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #744, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #746, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #754, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #997, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #1325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('needle' type=inline), + #1400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('negate' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('net' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('net' type=inline), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newCallback' type=dynamic), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newClass' type=dynamic), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newConfig' type=dynamic), + #1058, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newCursor' type=dynamic), + #1307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newFoldLine' type=dynamic), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newFoldLine' type=dynamic), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newLevel' type=dynamic), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newLineMode' type=dynamic), + #485, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newLineMode' type=dynamic), + #659, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newPos' type=inline), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newRange' type=dynamic), + #997, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newRange' type=dynamic), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newRange' type=dynamic), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newRanges' type=dynamic), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newRanges' type=dynamic), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newStart' type=dynamic), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newState' type=dynamic), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newToken' type=dynamic), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newValue' type=dynamic), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newValue' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('new_range' type=dynamic), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newlineLength' type=dynamic), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newlineLength' type=dynamic), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('next' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('next' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('next' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nextDelta' type=dynamic), + #1038, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nextLine' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('next_indent' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nl' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nl' type=inline), + #1345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nnr' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('noClip' type=inline), + #475, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('noScrollbar' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('noWidgets' type=dynamic), + #1389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('node' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('node' type=inline), + #1170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('normalizeCommandKeys' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('normalizeModule' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('normalizePath' type=dynamic), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('now' type=inline), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('now' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nr' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ns' type=inline), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ns' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ns' type=inline), + #1270, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('numRangeLastLineChars' type=dynamic), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('numRangeRows' type=dynamic), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('number' type=static), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #111, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #271, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetLeft' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetTop' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetX' type=inline), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetX' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetX' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsetX' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offsets' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('old' type=inline), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('old' type=inline), + #475, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('old' type=inline), + #1391, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldConfig' type=dynamic), + #1058, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldConfig' type=dynamic), + #1077, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldConfig' type=dynamic), + #1114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldLastRow' type=dynamic), + #1077, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldLastRow' type=dynamic), + #1114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldMode' type=inline), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldNode' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldRange' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldRange' type=dynamic), + #1326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldScrollTop' type=dynamic), + #242, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldSession' type=dynamic), + #905, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldSession' type=dynamic), + #1363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldSize' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldStart' type=dynamic), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldSteps' type=dynamic), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldWidget' type=dynamic), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onAfterRender' type=dynamic), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onBeforeRender' type=dynamic), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCaptureEnd' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCaptureInterval' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onChangeSelection' type=dynamic), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCompositionEnd' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCompositionStart' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCompositionUpdate' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onContextMenu' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onContextMenuClose' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCopy' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCreateCell' type=dynamic), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onCut' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onDragInterval' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onInput' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onKeyup' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onLoad' type=inline), + #281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onLoad' type=inline), + #284, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseDown' type=dynamic), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseDown' type=dynamic), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseMove' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseMove' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseMoveTimer' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseSelection' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseSelectionEnd' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMouseUp' type=dynamic), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onMousedown' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onOperationEnd' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onPaste' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onReloadTokenizer' type=dynamic), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onRender' type=dynamic), + #1157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onScreen' type=dynamic), + #1139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onSelect' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onSelectionInterval' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('openBracePos' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('openBracket' type=dynamic), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opening' type=inline), + #423, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opera' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt' type=inline), + #265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt' type=inline), + #266, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt' type=inline), + #270, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt' type=inline), + #272, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('optList' type=inline), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('optionHash' type=dynamic), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('optionNames' type=dynamic), + #262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #424, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #615, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #662, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #738, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #739, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #740, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #744, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #754, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #898, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #994, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #997, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #998, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #999, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #1006, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('optionsProvider' type=dynamic), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opts' type=inline), + #273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('orientedRange' type=dynamic), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('orientedRange' type=dynamic), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('orientedRange' type=dynamic), + #1336, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('originalRange' type=dynamic), + #958, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('originalRange' type=dynamic), + #959, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('os' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #1292, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('otherLines' type=dynamic), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('otherPos' type=dynamic), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('otherPos' type=dynamic), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('others' type=inline), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othersClass' type=dynamic), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('outer' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('outermostFolds' type=dynamic), + #595, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overflowEl' type=dynamic), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overwrite' type=dynamic), + #643, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overwrite' type=dynamic), + #937, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overwrite' type=dynamic), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overwrite' type=dynamic), + #1142, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ownerDocument' type=dynamic), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #85, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #135, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #1354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #1355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p1' type=inline), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p1' type=inline), + #104, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p1' type=inline), + #1303, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p1' type=inline), + #1362, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p2' type=inline), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p2' type=inline), + #104, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p2' type=inline), + #1303, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p2' type=inline), + #1362, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('packaged' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('packagedModule' type=dynamic), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1084, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1089, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1106, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1131, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #1242, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pagePos' type=inline), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pair' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('param' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('params' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parenClose' type=dynamic), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parenOpen' type=dynamic), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1144, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #1151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentEl' type=dynamic), + #1067, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentEl' type=dynamic), + #1087, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentEl' type=dynamic), + #1104, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentEl' type=dynamic), + #1128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentEl' type=dynamic), + #1162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentId' type=dynamic), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentId' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentId' type=dynamic), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentNode' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentNode' type=dynamic), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentNode' type=dynamic), + #184, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parentNode' type=dynamic), + #197, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parseFloat' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parseInt' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parts' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parts' type=inline), + #746, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parts' type=inline), + #763, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parts' type=inline), + #774, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pasted' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pasted' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #662, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #1273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('payload' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('payload' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pixelPos' type=dynamic), + #1140, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pixelPos' type=dynamic), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pixelPos' type=dynamic), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #561, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #601, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #1126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('platform' type=dynamic), + #757, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('platform' type=dynamic), + #758, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('platform' type=dynamic), + #780, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #472, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #474, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #568, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #570, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point' type=inline), + #1084, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point1' type=inline), + #473, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('point2' type=inline), + #473, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('popState' type=dynamic), + #397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #311, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #357, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #462, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #475, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #477, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #497, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #551, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #555, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #556, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #713, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #714, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #984, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #986, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1003, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1041, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1043, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1051, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1299, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1300, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1328, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('posLeft' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('posTop' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('posX' type=inline), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #466, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #493, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #494, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #495, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #499, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #501, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #621, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #641, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #675, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #762, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #766, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #1075, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('position' type=dynamic), + #1139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('positionInDocument' type=dynamic), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('postMessageId' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prefix' type=inline), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prefix' type=inline), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prefix' type=inline), + #462, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pressed' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pressedKeys' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prev' type=inline), + #902, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prev' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevCursor' type=dynamic), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevCursor' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevCursor' type=dynamic), + #213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevIndex' type=dynamic), + #332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevLine' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevLine' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevLineState' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevRange' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevScroll' type=dynamic), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevState' type=dynamic), + #319, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevToken' type=dynamic), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevToken' type=dynamic), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('preventDefault' type=dynamic), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('previous' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('processNext' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('processState' type=dynamic), + #402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('processedLines' type=dynamic), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('property' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('proto' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pushState' type=dynamic), + #397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('q' type=inline), + #1280, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('quote' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('quotes' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('quotes' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #381, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #382, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #391, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 50, + cond_init: true, + declared: true, + declared_count: 4, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 50, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #935, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1046, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1353, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r' type=inline), + #1355, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('r1' type=inline), + #381, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('radiusClass' type=dynamic), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #82, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #86, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #87, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 7, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #359, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #376, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #489, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #490, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #502, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #506, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #549, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #561, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #564, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #567, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #569, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #571, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #576, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #595, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #596, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 22, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #615, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #617, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #622, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #654, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #674, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #676, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #681, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #683, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #696, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #851, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #873, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #874, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #889, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #915, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #923, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #924, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #930, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #955, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #957, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #958, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #959, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #966, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #974, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #976, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #984, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #994, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #996, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #997, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1000, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1330, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1337, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range1' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rangeIndex' type=dynamic), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rangeList' type=dynamic), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #575, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #891, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #913, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 16, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1338, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ranges' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #653, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #744, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #746, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #924, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('re' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('readOnly' type=dynamic), + #157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('readOnly' type=dynamic), + #949, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('readOnly' type=dynamic), + #1010, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rearrangeUndoStack' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rebaseRedoStack' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #1084, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rect' type=inline), + #1171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rectSel' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rectSel' type=inline), + #1334, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rectSel' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('redoSelectionRange' type=dynamic), + #1036, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('redoStack' type=dynamic), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('redoStack' type=dynamic), + #1054, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('refs' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reg' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reg' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regExp' type=inline), + #119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regExp' type=inline), + #527, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regExp' type=inline), + #528, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regexpEnd' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regexpStart' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('relativeNumberRenderer' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('releaseCaptureHandler' type=dynamic), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removeListener' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #550, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #552, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1328, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1329, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removed' type=inline), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removedFolds' type=dynamic), + #633, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('removedFolds' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderTokens' type=dynamic), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #898, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1003, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('renderer' type=dynamic), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replaceRange' type=dynamic), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replaced' type=dynamic), + #994, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replaced' type=dynamic), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replacement' type=dynamic), + #743, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replacement' type=dynamic), + #994, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replacement' type=dynamic), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('replacement' type=dynamic), + #996, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reportError' type=dynamic), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reportErrorIfPathIsNotConfigured' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('req' type=inline), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #307, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #318, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #327, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #384, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #410, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #416, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #421, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #469, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #478, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #515, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #526, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #531, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #547, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #572, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #620, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #626, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #737, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #779, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #789, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1055, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1066, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1086, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1289, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1309, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1376, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1377, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #1405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 12, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('requirejs' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('res' type=inline), + #971, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reset' type=inline), + #1365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resetPressedKeys' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resetSelection' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 14, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolve' type=inline), + #253, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rest' type=inline), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('restoreEnd' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('restorePoint' type=dynamic), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('restoreRange' type=dynamic), + #560, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('restoreStart' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #108, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #971, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #1343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 26, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 26, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #415, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ret' type=inline), + #544, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('returnValue' type=dynamic), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rev' type=inline), + #1029, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rev' type=inline), + #1031, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rev' type=inline), + #1039, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reverse' type=inline), + #351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reverse' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('right' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('right' type=inline), + #1206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('right' type=inline), + #1207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightChar' type=dynamic), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightOfCursor' type=dynamic), + #367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightOfCursor' type=dynamic), + #369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightOfCursor' type=dynamic), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rightToken' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('root' type=inline), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #83, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #88, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #89, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #90, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #91, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #92, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #93, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #94, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #95, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #97, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #98, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #305, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #340, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #341, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #358, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #366, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #367, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #370, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #444, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #454, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #470, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #475, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #477, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #481, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #487, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #491, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #496, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #498, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #500, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #503, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #505, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #523, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #524, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #525, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #538, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #540, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #541, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #542, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #554, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #566, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #601, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #611, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #614, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #615, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #617, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #635, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #636, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #644, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #645, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #647, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #648, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #658, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #672, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #686, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #688, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #693, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #694, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #695, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #711, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #712, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #717, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #723, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #749, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #750, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #752, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #979, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #980, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #982, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #985, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #989, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1021, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1060, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1069, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1070, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1076, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1077, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1078, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1094, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 10, + usage_count: 16, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 7, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 7, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1217, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1240, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1379, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('row' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCache' type=dynamic), + #331, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCache' type=dynamic), + #332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCache' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCache' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCount' type=dynamic), + #418, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCount' type=dynamic), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowCount' type=dynamic), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowDiff' type=inline), + #423, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowDiff' type=inline), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowEnd' type=inline), + #360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowEnd' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowInfo' type=inline), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowLength' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowMap' type=inline), + #326, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowRange' type=dynamic), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowShift' type=dynamic), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowStart' type=dynamic), + #360, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowTokens' type=dynamic), + #419, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #619, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #646, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #661, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #922, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #961, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #965, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #972, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rows' type=inline), + #1218, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rowsBefore' type=dynamic), + #1052, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rtlCandidate' type=dynamic), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 33, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 33, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 44, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 43, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rule' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ruleItr' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ruleRegExps' type=dynamic), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rules' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rules' type=inline), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rules' type=inline), + #402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rules' type=inline), + #461, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #967, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sameRowRanges' type=dynamic), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sbm' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sc' type=inline), + #741, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scope' type=inline), + #458, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenAnchor' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenAnchor' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenAnchor' type=dynamic), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #710, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #718, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #719, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #720, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #727, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenColumn' type=dynamic), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenCursor' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenCursor' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenLead' type=dynamic), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenLines' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenPage' type=dynamic), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenPos' type=dynamic), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenPos' type=dynamic), + #708, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenPosEnd' type=dynamic), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenPosStart' type=dynamic), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #329, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #364, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #713, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #714, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #715, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #716, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #719, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #720, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRow' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRowOffset' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRows' type=dynamic), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenRows' type=dynamic), + #1380, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('screenTop' type=dynamic), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('script' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('script' type=inline), + #1265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scriptOptions' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 20, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scriptUrl' type=dynamic), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scripts' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollAnchor' type=dynamic), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollCursor' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollCursorIntoView' type=dynamic), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollHeight' type=dynamic), + #1210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollIntoView' type=dynamic), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollLeft' type=dynamic), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollLeft' type=dynamic), + #668, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollLeft' type=dynamic), + #1155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollLeft' type=dynamic), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollLeft' type=dynamic), + #1229, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollPastEnd' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #667, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #1000, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #1150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollTop' type=dynamic), + #1228, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollerHeight' type=dynamic), + #1210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('search' type=inline), + #1324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('secondCondition' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #901, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #973, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sel' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selColMax' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selColMin' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('select' type=inline), + #981, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('select' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #228, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #423, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selected' type=dynamic), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectedCount' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectedRange' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectedText' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #423, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #905, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #962, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #995, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1029, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1031, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selection' type=dynamic), + #1347, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEmpty' type=dynamic), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 7, + mutation_by_call_count: 6, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 10, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #991, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionEnd' type=dynamic), + #993, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionMode' type=dynamic), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionRange' type=dynamic), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionRange' type=dynamic), + #201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #890, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #990, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selectionStart' type=dynamic), + #992, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selections' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selections' type=dynamic), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('selections' type=dynamic), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: false, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 30, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 30, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #516, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #638, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #912, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #916, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1165, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sendText' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sender' type=inline), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sendingText' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sep' type=inline), + #279, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #305, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #328, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #346, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #417, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #433, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #435, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #436, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #456, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #462, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #558, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #610, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #740, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #898, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #905, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #913, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #923, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #924, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #963, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1021, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1022, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1027, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1028, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1035, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1036, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1059, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1060, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1065, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1068, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1073, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1074, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1090, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1187, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1291, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1293, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1298, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1371, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1378, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setInterval' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 37, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 26, + usage_count: 37, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sheets' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shift' type=inline), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shift' type=inline), + #534, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shift' type=inline), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 20, + usage_count: 20, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shift' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shiftPos' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldAnimate' type=dynamic), + #944, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldAnimate' type=dynamic), + #1194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #941, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #942, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #943, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #1009, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #1201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldHighlight' type=dynamic), + #1253, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldInsertSpace' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldMerge' type=dynamic), + #902, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldOutdent' type=dynamic), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldRemove' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldReset' type=dynamic), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shouldScroll' type=dynamic), + #1002, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #952, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1017, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1081, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1082, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('show' type=inline), + #1252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showContextMenu' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showInvisibles' type=dynamic), + #337, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showInvisibles' type=dynamic), + #945, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showInvisibles' type=dynamic), + #1110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showInvisibles' type=dynamic), + #1195, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #947, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #948, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #1197, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #1198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showTooltip' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('side' type=inline), + #573, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('simpleSpace' type=dynamic), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #687, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #911, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #1164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #1170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #1256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skip' type=inline), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skip' type=inline), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skipCurrent' type=dynamic), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skipped' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sm' type=inline), + #1206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sm' type=inline), + #1207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sm' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('smoothBlinking' type=dynamic), + #1135, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('solve' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaceClass' type=dynamic), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaceContent' type=dynamic), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaceOffset' type=dynamic), + #1354, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaceOffsets' type=dynamic), + #1351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaces' type=inline), + #448, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('spaces' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('span' type=inline), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 3, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('span' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: true, + declared: true, + declared_count: 5, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('speed' type=inline), + #938, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 45, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 10, + mutation_by_call_count: 6, + usage_count: 35, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitChar' type=dynamic), + #406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitChars' type=dynamic), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitDelta' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitIndex' type=dynamic), + #329, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitIndex' type=dynamic), + #332, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitIndex' type=dynamic), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitIndex' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #333, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #713, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #725, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splitterRurles' type=dynamic), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('square' type=inline), + #394, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sr' type=inline), + #741, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('src' type=inline), + #285, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('src' type=inline), + #391, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('src' type=inline), + #393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('st' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #400, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #401, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1030, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1031, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1035, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1038, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #1041, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #99, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #351, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #378, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #445, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #467, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #495, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #501, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #502, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #503, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #529, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #574, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #581, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #657, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #748, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 10, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1042, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1051, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #1386, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startCol' type=dynamic), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startCol' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #81, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #468, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #503, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startColumn' type=dynamic), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFold' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFoldLine' type=dynamic), + #579, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFoldLine' type=dynamic), + #580, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFoldRow' type=dynamic), + #597, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFoldRow' type=dynamic), + #598, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startFoldRow' type=dynamic), + #599, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #548, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #549, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startIndex' type=dynamic), + #753, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startLevel' type=dynamic), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startLine' type=dynamic), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startLine' type=dynamic), + #742, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startOffsetX' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRange' type=dynamic), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRange' type=dynamic), + #623, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #81, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #504, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #513, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #514, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #521, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #522, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #557, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #559, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #584, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #588, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #602, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #654, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #686, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #751, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #1387, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startState' type=dynamic), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startW' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startX' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startX' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startY' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startY' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #295, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #426, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #428, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #430, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #432, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #452, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #453, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #454, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #459, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #460, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #462, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #525, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #965, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #966, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stateName' type=dynamic), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('states' type=inline), + #399, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stepCount' type=dynamic), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('steps' type=inline), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('steps' type=inline), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stop' type=inline), + #300, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stop' type=inline), + #539, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stopAtFirst' type=dynamic), + #1350, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stopPropagation' type=dynamic), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #286, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #710, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #727, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('str' type=inline), + #881, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('strictCSP' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #107, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #108, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringAfter' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBefore' type=dynamic), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1096, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringBuilder' type=dynamic), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringifyDelta' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringifyRange' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #612, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #909, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #910, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #924, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1005, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1008, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1083, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #1336, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('styles' type=inline), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sub' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subFold' type=inline), + #565, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subFold' type=inline), + #585, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subFold' type=inline), + #592, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subRows' type=inline), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subst' type=inline), + #280, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('success' type=inline), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('superCtor' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('swap' type=inline), + #957, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('swap' type=inline), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('swapGroups' type=dynamic), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('swapped' type=inline), + #1041, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('switchToSelectionMode' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('syncComposition' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #968, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #1174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #1175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #1225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tab' type=inline), + #452, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tab' type=inline), + #933, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tab' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabClass' type=dynamic), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabContent' type=dynamic), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #361, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #362, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #363, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #640, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #709, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #732, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabSize' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tabStr' type=inline), + #1112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #195, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #219, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tempStyle' type=dynamic), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('test' type=inline), + #608, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('testRemove' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 77, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 25, + usage_count: 79, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #140, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #185, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #317, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #425, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #427, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #429, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #480, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #482, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #483, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #484, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #486, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #494, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #495, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #506, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #627, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #634, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #656, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #675, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #683, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #902, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #927, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #928, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #929, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #934, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #935, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #954, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #958, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #959, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #960, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #978, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #1237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #1345, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #1407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textCharTypes' type=dynamic), + #324, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textCharTypes' type=dynamic), + #325, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textCharTypes' type=dynamic), + #335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textContent' type=dynamic), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textEnd' type=inline), + #365, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textLayer' type=dynamic), + #1183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textLine' type=dynamic), + #600, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textLine' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textNode' type=dynamic), + #1079, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textNode' type=dynamic), + #1085, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textOrLines' type=dynamic), + #479, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textW' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textarea' type=dynamic), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('that' type=inline), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #908, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #1183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #1241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('throwDeltaError' type=dynamic), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('time' type=inline), + #176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timeout' type=inline), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timeout' type=inline), + #122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timeout' type=inline), + #124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timeout' type=inline), + #125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timeouts' type=dynamic), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timer' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timer' type=inline), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timer' type=inline), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timerId' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timerId' type=inline), + #296, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timerId' type=inline), + #1304, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('times' type=inline), + #990, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('times' type=inline), + #991, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('times' type=inline), + #992, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('times' type=inline), + #993, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tl' type=inline), + #1095, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tlns' type=inline), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tmp' type=inline), + #320, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tmp' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tmpSel' type=inline), + #1306, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tmpSel' type=inline), + #1344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tmpToken' type=dynamic), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #511, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #1030, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #1032, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #1033, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #1034, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('to' type=inline), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toExecute' type=dynamic), + #315, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toInsert' type=dynamic), + #403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toPosition' type=dynamic), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toPosition' type=dynamic), + #974, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toRange' type=inline), + #684, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toRemove' type=dynamic), + #1348, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toValue' type=inline), + #1224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toValue' type=inline), + #1227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toggleParent' type=dynamic), + #617, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #417, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #420, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #434, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #451, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #611, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #707, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #917, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 18, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #987, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 27, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 25, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('token' type=inline), + #1373, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokenIndex' type=dynamic), + #419, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokenRe' type=inline), + #369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokenizer' type=dynamic), + #516, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokenizer' type=dynamic), + #518, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokenizer' type=dynamic), + #664, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #444, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #611, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #637, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tooltip' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tooltipAnnotation' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tooltipTimeout' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1003, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1093, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1099, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('top' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('topLevelNamespaces' type=dynamic), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('topLevelNamespaces' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('topMargin' type=dynamic), + #1221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('totalDiff' type=dynamic), + #975, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('touchObj' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('touchObj' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('touchStartT' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('touches' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('touches' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tr' type=inline), + #1095, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('transform' type=dynamic), + #932, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('trim' type=inline), + #578, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('trimBeginRegexp' type=dynamic), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('trimEndRegexp' type=dynamic), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tryToUnfold' type=dynamic), + #606, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ts' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ts' type=inline), + #1158, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tx' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tx' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('txt' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ty' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ty' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #215, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #527, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #607, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #616, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #649, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #1045, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 6, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #1071, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #1239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typeRe' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typeRe' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typeRe' type=inline), + #1374, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typeRe' type=inline), + #1375, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('types' type=inline), + #214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('types' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('types' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('types' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('types' type=inline), + #434, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typing' type=inline), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typingResetTimeout' type=dynamic), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('u' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ua' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uc' type=inline), + #322, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('unAlign' type=inline), + #1356, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uncomment' type=dynamic), + #441, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undefined' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 42, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 15, + usage_count: 42, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undoManager' type=dynamic), + #638, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undoManager' type=dynamic), + #1301, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undoSelectionRange' type=dynamic), + #1035, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undoStack' type=dynamic), + #1290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undosRequired' type=dynamic), + #1301, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('unicode' type=inline), + #440, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('unitName' type=dynamic), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('unixMode' type=dynamic), + #1105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('update' type=inline), + #1138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('updateMarker' type=dynamic), + #1298, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('updateMenu' type=dynamic), + #227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uri' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('url' type=static), + #244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('url' type=static), + #247, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useWorker' type=dynamic), + #660, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useWorker' type=dynamic), + #731, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useWrapMode' type=dynamic), + #697, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useWrapMode' type=dynamic), + #702, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #288, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #756, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #897, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #1161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #1182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('useragent' type=dynamic), + #1302, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ut' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vMovement' type=dynamic), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vMovement' type=dynamic), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vScroll' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vScroll' type=inline), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vScroll' type=inline), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vScrollBefore' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vScrollChanged' type=dynamic), + #1213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vX' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vY' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #631, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #639, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #730, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #733, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #734, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #735, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #736, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #906, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #940, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1012, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1013, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1014, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1015, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1016, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1263, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1283, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1368, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('val' type=inline), + #1369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('validateDelta' type=dynamic), + #464, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #158, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #408, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #409, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #729, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 11, + usage_count: 11, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1011, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1018, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1020, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1247, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #1406, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueFragment' type=dynamic), + #1117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueIndex' type=dynamic), + #624, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueIndex' type=dynamic), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueLength' type=dynamic), + #625, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueResetRegex' type=dynamic), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('values' type=inline), + #389, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('values' type=inline), + #390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('visIdx' type=inline), + #343, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('visualIdx' type=dynamic), + #342, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('visualIdx' type=dynamic), + #344, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 25, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 22, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vx' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('vy' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #670, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1381, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1385, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1388, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1390, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1391, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 30, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 30, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1395, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1396, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1397, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 22, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1398, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 22, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1402, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w' type=inline), + #1403, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('w1' type=inline), + #1393, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wType' type=inline), + #321, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('waitForClickSelection' type=dynamic), + #173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('walkTokens' type=dynamic), + #705, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('warn' type=inline), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wasEmpty' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wasMultiselect' type=dynamic), + #352, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('weightedDistance' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wheelX' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wheelY' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('whitespaceRe' type=dynamic), + #369, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('widget' type=inline), + #372, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #339, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #669, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1097, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1098, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1153, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1154, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #1211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('win' type=inline), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('win' type=inline), + #790, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('win' type=inline), + #1157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('window' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 50, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 14, + usage_count: 50, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('windowBlurred' type=dynamic), + #290, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('windowHeight' type=dynamic), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('windowWidth' type=dynamic), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('withScrollbar' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('word' type=inline), + #407, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('word' type=inline), + #463, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordBoundary' type=dynamic), + #754, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordChars' type=dynamic), + #439, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordPairs' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordParts' type=dynamic), + #969, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordRange' type=dynamic), + #658, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordRe' type=inline), + #431, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wordWithBoundary' type=dynamic), + #925, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('words' type=inline), + #1349, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('worker' type=inline), + #1268, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('workerClient' type=dynamic), + #1281, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('workerStart' type=dynamic), + #517, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('workerUrl' type=dynamic), + #1265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('workerUrl' type=dynamic), + #1267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('workerUrl' type=dynamic), + #1269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrap' type=inline), + #921, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapData' type=dynamic), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapIndent' type=dynamic), + #721, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapIndent' type=dynamic), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapLimit' type=dynamic), + #699, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapLimit' type=dynamic), + #700, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapLimit' type=dynamic), + #704, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapLimit' type=dynamic), + #706, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapRow' type=inline), + #722, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #187, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #404, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #405, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #685, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #689, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #775, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #786, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #788, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1037, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1092, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('xBackwards' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x_min' type=inline), + #1225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('xform' type=inline), + #1026, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('xformed' type=inline), + #1053, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('xhr' type=inline), + #244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #187, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #392, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #1230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #1233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #1234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #1235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('yBackwards' type=dynamic), + #1335, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('zoom' type=inline), + #1176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ], +} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/input.js similarity index 100% rename from crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/8a28b14e.d8fbda268ed281a1/input.js rename to crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug new file mode 100644 index 000000000000..13c207298145 --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug @@ -0,0 +1,52684 @@ +TestSnapshot { + vars: [ + ( + ( + Atom('Array' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 17, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 9, + usage_count: 17, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ArrayBuffer' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Buffer' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('C' type=inline), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('COMPARE_PARTIAL_FLAG' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('COMPARE_UNORDERED_FLAG' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Ctor' type=inline), + #171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Ctor' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DIFF_DELETE' type=dynamic), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 27, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 27, + usage_count: 27, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DIFF_EQUAL' type=dynamic), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 41, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 41, + usage_count: 41, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DIFF_INSERT' type=dynamic), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 26, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 26, + usage_count: 26, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DataView' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Date' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DiffComponent' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DiffComponent' type=dynamic), + #232, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('DiffMatchPatch' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EditSession' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Editor' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Error' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 14, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('EventEmitter' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('FUNC_ERROR_TEXT' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Function' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HASH_UNDEFINED' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('HASH_UNDEFINED' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Hash' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Hash' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('INFINITY' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LARGE_ARRAY_SIZE' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ListCache' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ListCache' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MAX_SAFE_INTEGER' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Map' type=static), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Map' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MapCache' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('MapCache' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Math' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 22, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 22, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Number' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Object' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 38, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 12, + usage_count: 38, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Promise' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PropTypes' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 53, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 53, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PropTypes' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 30, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 30, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('PropTypes' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 51, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 51, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('React' type=static), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('React' type=static), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('React' type=static), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactAce' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactAce' type=dynamic), + #201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 23, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactIs' type=inline), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactPropTypes' type=dynamic), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactPropTypesSecret' type=dynamic), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReactPropTypesSecret' type=dynamic), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('RegExp' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Renderer' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Set' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SetCache' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Split' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SplitComponent' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('SplitComponent' type=dynamic), + #253, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 21, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Stack' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('String' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Symbol' type=static), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Symbol' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TypeError' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Uint8Array' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('WeakMap' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__' type=inline), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__' type=inline), + #231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__' type=inline), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__assign' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__assign' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__extends' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__extends' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__extends' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #218, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #219, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_a' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_b' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_b' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_b' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_b' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_super' type=inline), + #201, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_super' type=inline), + #232, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_super' type=inline), + #253, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 15, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('accuracy' type=dynamic), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace' type=inline), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace' type=inline), + #242, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace' type=inline), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace_1' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace_builds_1' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ace_builds_1' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #206, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('annotations' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appliedClasses' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appliedClasses' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appliedClassesArray_1' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appliedClassesArray_1' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arg' type=inline), + #123, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('argsTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arguments' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrLength' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrValue' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #85, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('array' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayBufferTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayFilter' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayLikeKeys' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayProto' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayProto' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayPush' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arraySome' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arrayTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('assocIndexOf' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('assocIndexOf' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('asyncTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('availableOptions' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('availableOptions' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #196, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #197, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #228, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #229, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseGet' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseGetAllKeys' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseGetTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsArguments' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsEqual' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsEqualDeep' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsNative' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsNative' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseIsTypedArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseKeys' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseTimes' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseToString' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('baseUnary' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bestEdit' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bestEquality1' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bestEquality2' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bestScore' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_common' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_loc' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_longtext_a' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_longtext_b' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_shorttext_a' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('best_shorttext_b' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bigpatch' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bin_max' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bin_mid' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bin_min' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bitmask' type=inline), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bitmask' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bitmask' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bitmask' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('bitmask' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blankLine1' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('blankLine2' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('boolTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cache' type=inline), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cache' type=inline), + #118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cacheHas' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('castPath' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('changes' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('char1' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('char2' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('charMatch' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('char_count1' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('char_count2' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars1' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars1' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars2' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chars2' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('checklines' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('checklines' type=dynamic), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chunk' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('chunkType' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('className' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clearTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('codeEditorSettings' type=dynamic), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('codeEditorSettings' type=dynamic), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #208, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('command' type=inline), + #259, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commands' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonOffset' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonString' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonlength' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonlength' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonprefix' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('commonsuffix' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('compared' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('compared' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('componentName' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('console' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('container' type=dynamic), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('context' type=inline), + #244, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('convert' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('coords1' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('coords2' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('coreJsData' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('coreJsData' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count_delete' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count_delete' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count_insert' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('count_insert' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ctorString' type=dynamic), + #171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentMarkers' type=dynamic), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('currentMarkers' type=dynamic), + #275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursor' type=inline), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('cursorStart' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('customizer' type=dynamic), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('customizer' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('customizer' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('customizer' type=dynamic), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('customizer' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 10, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #196, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #197, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #199, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #228, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #229, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #231, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #248, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #249, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #251, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #72, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #74, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #76, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #77, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #90, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #130, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #131, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #134, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('data' type=inline), + #165, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dataViewCtorString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dataViewTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dateTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deadline' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deadline' type=dynamic), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deadline' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deadline' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deadline' type=dynamic), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('debounce' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('decodeURI' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultValue' type=dynamic), + #109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultValue' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultValue' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('defaultValueForEditor' type=dynamic), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delay' type=inline), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deletion' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('deletions' type=dynamic), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('delta' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff' type=inline), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_1' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_cleanupSemanticScore_' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_halfMatchI_' type=dynamic), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_linesToCharsMunge_' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_match_patch' type=dynamic), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 93, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 93, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_text' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_text' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_type' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diff_type' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffedLines' type=dynamic), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffedLines' type=dynamic), + #237, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffedLines' type=dynamic), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 23, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 23, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 47, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 47, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 18, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffsLength' type=dynamic), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs_a' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffs_b' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('diffsb' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('divStyle' type=dynamic), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('divStyle' type=dynamic), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dmp' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dmp' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dmp' type=inline), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('document' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #68, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #99, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #100, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #111, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #168, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #178, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #179, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('edit' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 26, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 26, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 15, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #264, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #266, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #268, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editor' type=inline), + #275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorEvents' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorHeight' type=dynamic), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorOptions' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorOptions_1' type=dynamic), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorOptions_1' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorProps' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorProps' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('editorWidth' type=dynamic), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('el' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('empty' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('emptyFunction' type=dynamic), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: true, + infects: [], + }, + ), + ( + ( + Atom('emptyFunctionWithReset' type=dynamic), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: true, + infects: [], + }, + ), + ( + ( + Atom('encodeURI' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endCol' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endCol' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('endRow' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('end_loc' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entries' type=inline), + #145, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('entry' type=inline), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eq' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('eq' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalArrays' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalByTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalFunc' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalFunc' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalFunc' type=dynamic), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalFunc' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalObjects' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalities' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalities' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalitiesLength' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equalitiesLength' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equality1' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('equality2' type=dynamic), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('err' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('errorTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #215, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #216, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #217, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #263, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #269, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #270, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('event' type=inline), + #271, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ex' type=inline), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ex' type=inline), + #63, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('expected_loc' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ext_split_1' type=dynamic), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extendStatics' type=dynamic), + #195, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extendStatics' type=dynamic), + #227, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extendStatics' type=dynamic), + #247, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('extraLength' type=dynamic), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('finish' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('firstChar' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('float32Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('float64Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fn' type=inline), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('focus' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('focus' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fontSize' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fontSize' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('found' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeExports' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeGlobal' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeGlobal' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeModule' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeProcess' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeSelf' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('freeSelf' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('front' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #94, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #98, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #116, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #174, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('func' type=inline), + #177, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcProto' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcProto' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcTag' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcToString' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('funcToString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('genTag' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('genTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('get' type=static), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('get' type=static), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getAceInstance' type=dynamic), + #241, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getAllKeys' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getMapData' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getMapData' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getNative' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getNative' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getRawTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getShim' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getSymbols' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getValue' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getValue' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasOwnProperty' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasOwnProperty' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashClear' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashClear' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashDelete' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashDelete' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashGet' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashGet' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashHas' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashHas' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashSet' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hashSet' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('height' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hm' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hm' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hm1' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hm2' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('html' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('idx' type=inline), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('idx' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inFront' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #76, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #77, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #86, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #134, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #142, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index' type=inline), + #262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index1' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('index2' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('inherited' type=dynamic), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('insertion' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('insertions' type=dynamic), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('int16Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('int32Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('int8Tag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArg' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArguments' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArr' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArray' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArray' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isArrayLike' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isBuff' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isBuffer' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isEqual' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isEqual' type=inline), + #194, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isEqual' type=inline), + #246, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFunction' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isFunction' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isHostObject' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isIndex' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isKey' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isKeyable' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isKeyable' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isLength' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isMasked' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isMasked' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isNaN' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isObject' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isObject' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isObjectLike' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isObjectLike' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isOwn' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isPartial' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isPartial' type=dynamic), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isPartial' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isPrototype' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSameTag' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isSymbol' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isType' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isTypedArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isUsed' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('item' type=inline), + #224, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('item' type=inline), + #277, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('iteratee' type=dynamic), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('j' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k1' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k1_offset' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 11, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k1end' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k1start' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k2' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k2_offset' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k2end' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('k2start' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #71, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #72, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #73, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #74, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #76, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #77, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #78, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #81, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #82, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #83, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #85, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #90, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #91, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #118, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #130, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #131, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #134, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #135, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #139, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #140, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #147, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #148, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #159, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #165, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #166, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keybinding' type=dynamic), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyboardHandler' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keyboardHandler' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keys' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('keysFunc' type=dynamic), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lang' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastChar' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastEquality' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastEquality' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastIndex' type=dynamic), + #76, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lastIndex' type=dynamic), + #133, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last_chars1' type=dynamic), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last_chars2' type=dynamic), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('last_rd' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #70, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #75, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #80, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #85, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #86, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #127, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #132, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #137, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #142, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #151, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length' type=static), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length_deletions1' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length_deletions2' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length_insertions1' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('length_insertions2' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('levenshtein' type=dynamic), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lhString' type=dynamic), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('line' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineArray' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineArray' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineArrayLength' type=dynamic), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineBreak1' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineBreak2' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineEnd' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineHash' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lineStart' type=dynamic), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('linearray' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('lines' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('linesToHighlight' type=dynamic), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheClear' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheClear' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheDelete' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheDelete' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheGet' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheGet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheHas' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheHas' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheSet' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('listCacheSet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loc' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loc' type=inline), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loc' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 9, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('location' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longtext' type=dynamic), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longtext' type=dynamic), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('longtext' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #22, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('m' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #90, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('map' type=inline), + #165, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheClear' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheClear' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheDelete' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheDelete' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheGet' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheGet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheHas' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheHas' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheSet' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCacheSet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapCtorString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mapToArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('margins' type=inline), + #211, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markerObj' type=dynamic), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #221, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #240, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('markers' type=inline), + #275, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maskSrcKey' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maskSrcKey' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match' type=inline), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('match_bitapScore_' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('matchmask' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('maxLines' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('max_d' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('memoize' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('memoized' type=dynamic), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('method' type=inline), + #203, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('method' type=inline), + #255, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mid_common' type=dynamic), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mid_common' type=dynamic), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mod' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('mode' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #189, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #193, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleExports' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('n' type=inline), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('name' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeCreate' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeCreate' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeGetSymbols' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeIsBuffer' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeKeys' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nativeObjectToString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newAnnotations' type=dynamic), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newAnnotations' type=dynamic), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newMarkerSet' type=dynamic), + #239, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newMarkers' type=dynamic), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('newMarkers' type=dynamic), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nextProps' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 37, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 37, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nextProps' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 32, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 32, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nextValue' type=dynamic), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('node' type=inline), + #204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('node' type=inline), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('node' type=inline), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nodeIsTypedArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nodeUtil' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nonAlphaNumeric1' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nonAlphaNumeric2' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nullPadding' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nullPadding' type=dynamic), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('nullTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('number' type=static), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('numberTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objCtor' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objIsArr' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objIsObj' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objIsWrapped' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objLength' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objProps' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objTag' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objUnwrapped' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objValue' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #66, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #86, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #91, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #92, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #119, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 9, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #159, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 8, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #164, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #166, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #169, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('object' type=static), + #188, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objectProto' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objectProto' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objectTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objectToString' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('objectToString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('offset' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldAnnotations' type=dynamic), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldClass' type=dynamic), + #210, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldClass' type=dynamic), + #262, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldClassesArray' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldClassesArray' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldMarkers' type=dynamic), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldProps' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 15, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oldProps' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 16, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onBeforeLoad' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onBeforeLoad' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onLoad' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onLoad' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('onValidate' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('one' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('oop' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('op' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('op' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('op' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('op' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt_b' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt_c' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt_checklines' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opt_deadline' type=dynamic), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('option' type=inline), + #207, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('option' type=inline), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('option' type=inline), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('option' type=inline), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('orientation' type=dynamic), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othCtor' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othIndex' type=dynamic), + #161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othIsArr' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othIsObj' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othIsWrapped' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othLength' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othLength' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othProps' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othTag' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othUnwrapped' type=dynamic), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othValue' type=dynamic), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othValue' type=dynamic), + #161, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('othValue' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 8, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 7, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 11, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('other' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overArg' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overlap_length1' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('overlap_length2' type=dynamic), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #198, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #230, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #250, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('padding' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('paddingLength' type=dynamic), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 13, + usage_count: 13, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pairs' type=inline), + #149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('param' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #204, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parent' type=inline), + #256, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('parseInt' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 19, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 19, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 26, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 26, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 20, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 20, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patchCopy' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patchDiffLength' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patchHeader' type=dynamic), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patch_size' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patches' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('patchesCopy' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #86, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('path' type=inline), + #109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #87, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern' type=inline), + #157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern_amp' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern_gt' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern_lt' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pattern_para' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('placeholder' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 32, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 7, + mutation_by_call_count: 10, + usage_count: 25, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 61, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 10, + mutation_by_call_count: 18, + usage_count: 52, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointer' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointerend' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermax' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermax' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermid' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermid' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermin' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointermin' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pointerstart' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pos' type=inline), + #261, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('post_del' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('post_ins' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('postcontext' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('postpatch_text' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pre_del' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pre_ins' type=inline), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('precontext' type=dynamic), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('predicate' type=dynamic), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('predicate' type=dynamic), + #114, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prefix' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prefixLength' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prepatch_text' type=dynamic), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevProps' type=dynamic), + #209, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('prevProps' type=dynamic), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('promiseCtorString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('promiseTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('propFullName' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('propName' type=dynamic), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('propertyIsEnumerable' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #202, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #233, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #254, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('proto' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('proximity' type=dynamic), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('proxyTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('quote' type=inline), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('range' type=inline), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rd' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reEscapeChar' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsDeepProp' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsHostCtor' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsHostCtor' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsNative' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsNative' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsPlainProp' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reIsUint' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reLeadingDot' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rePropName' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reRegExpChar' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reRegExpChar' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('regexpTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('require' type=static), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resIndex' type=dynamic), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolver' type=dynamic), + #101, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #72, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #88, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #95, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #97, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #102, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #109, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #115, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #120, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #128, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #129, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #138, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #146, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #159, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('results' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('rhString' type=dynamic), + #236, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('root' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('root' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('s' type=inline), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scope' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('score' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('score' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('score_threshold' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollMargin' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('scrollMargin' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('secret' type=inline), + #191, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('seed' type=inline), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('seen' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('session' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('set' type=static), + #124, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setCacheAdd' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setCacheHas' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setCtorString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setOptions' type=dynamic), + #220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setOptions' type=dynamic), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setTag' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setToArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shim' type=inline), + #190, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 14, + usage_count: 15, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shorttext' type=dynamic), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shorttext' type=dynamic), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('shorttext' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showGutter' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showGutter' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPlaceholder' type=dynamic), + #223, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('showPrintMargin' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sign' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('size' type=inline), + #141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skipCtor' type=dynamic), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('skipIndexes' type=dynamic), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sp' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splice' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splice' type=inline), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split' type=inline), + #260, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split_1' type=inline), + #226, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('split_1' type=inline), + #245, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('splits' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #156, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stack' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stackClear' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stackDelete' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stackGet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stackHas' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stackSet' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stacked' type=inline), + #160, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stacked' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stacked' type=inline), + #163, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start1' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start2' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startCol' type=dynamic), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startCol' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('startRow' type=dynamic), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('start_loc' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 16, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 13, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #95, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('string' type=static), + #96, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stringToPath' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stubArray' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('stubFalse' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('style' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subDiff' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('suffix' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('suffixLength' type=dynamic), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symToStringTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbol' type=static), + #170, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolProto' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolProto' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolTag' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolToString' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolValueOf' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('symbolsFunc' type=dynamic), + #152, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #200, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('t' type=inline), + #252, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #104, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #162, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tag' type=inline), + #184, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 21, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 6, + usage_count: 16, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #218, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #219, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #238, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #272, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text' type=inline), + #273, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 7, + usage_count: 13, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_a' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_a' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_b' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_b' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_length' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 9, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1_length' type=dynamic), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1a' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text1b' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 12, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 8, + usage_count: 12, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_a' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_a' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_b' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_b' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_length' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2_length' type=dynamic), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2a' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text2b' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textPointer' type=dynamic), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text_delete' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text_delete' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 11, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text_insert' type=dynamic), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text_insert' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 15, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 3, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('text_length' type=dynamic), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('textline' type=dynamic), + #62, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('theme' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('throwOnDirectAccess' type=dynamic), + #192, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('timer' type=inline), + #243, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toKey' type=inline), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toSource' type=dynamic), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toSource' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('toString' type=static), + #65, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('tokens' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('transform' type=dynamic), + #122, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('two' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #92, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #93, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #186, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #222, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('type' type=static), + #276, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('typedArrayTags' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 25, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 25, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uid' type=inline), + #69, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uid' type=inline), + #126, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uint16Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uint32Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uint8ClampedTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('uint8Tag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undefined' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 32, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 32, + usage_count: 32, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undefinedTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undoManager' type=dynamic), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('unmasked' type=dynamic), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('v1' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('v2' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('v_length' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('v_offset' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 5, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #67, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #74, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #79, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #84, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #87, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #88, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #89, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #91, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #92, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #93, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #97, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #103, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #104, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #105, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #106, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #107, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #108, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #112, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #117, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #121, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #125, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #131, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #136, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #141, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #143, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #144, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #149, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #150, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 7, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #153, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #154, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #155, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #157, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #158, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #166, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #167, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #171, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #172, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #173, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #175, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #176, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #180, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #181, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #182, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #183, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #184, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #185, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #186, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #187, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #212, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #213, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #214, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #234, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #235, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('valueForEditor' type=dynamic), + #258, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value_1' type=inline), + #263, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value_2' type=inline), + #265, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value_3' type=inline), + #267, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('values' type=inline), + #113, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('values' type=inline), + #142, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('weakMapCtorString' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('weakMapTag' type=dynamic), + #110, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('whitespace1' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('whitespace2' type=dynamic), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #225, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('width' type=inline), + #278, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('window' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapEnabled' type=dynamic), + #205, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('wrapEnabled' type=dynamic), + #257, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 9, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 5, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: true, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #60, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 4, + usage_count: 6, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #61, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x' type=inline), + #64, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x1' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 4, + mutation_by_call_count: 11, + usage_count: 12, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('x2' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 13, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 5, + mutation_by_call_count: 9, + usage_count: 10, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #220, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y' type=inline), + #274, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y1' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 2, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 6, + usage_count: 7, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('y2' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ], +} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js similarity index 100% rename from crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/981.ed660b563826161d/input.js rename to crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug new file mode 100644 index 000000000000..a99349924c1a --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug @@ -0,0 +1,4344 @@ +TestSnapshot { + vars: [ + ( + ( + Atom('App' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('App' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Boolean' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Component' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Component' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Constructor' type=dynamic), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Constructor' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Derived' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('NewTarget' type=dynamic), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Object' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 10, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 10, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Promise' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Proxy' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ReferenceError' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Reflect' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Super' type=inline), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Symbol' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TypeError' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_Component' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_N_E' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exec__' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exports__' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_appGetInitialProps' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_assertThisInitialized' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_asyncToGenerator' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_callee' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_callee$' type=dynamic), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_classCallCheck' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_createClass' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_createSuper' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_createSuperInternal' type=dynamic), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_ctx' type=inline), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_defineProperties' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_getPrototypeOf' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_getPrototypeOf' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_inherits' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_interopRequireDefault' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_interopRequireDefault1' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_isNativeReflectConstruct' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_next' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_next' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_possibleConstructorReturn' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_props' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_react' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_runtimeJs' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_setPrototypeOf' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_setPrototypeOf' type=dynamic), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_super' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_throw' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_throw' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_typeof' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_utils' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('appGetInitialProps' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arg' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('args' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arguments' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('asyncGeneratorStep' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('call' type=static), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ctx' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('descriptor' type=dynamic), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('err' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('error' type=inline), + #22, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('fn' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gen' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('gen' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('get' type=static), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('get' type=static), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('hasNativeReflectConstruct' type=dynamic), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('info' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('instance' type=dynamic), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleId' type=dynamic), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('o' type=inline), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('o' type=inline), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('o' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('o' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('p' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pageProps' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pageProps' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('param' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('protoProps' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reject' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reject' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('render' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolve' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolve' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('result' type=inline), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: false, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('staticProps' type=dynamic), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subClass' type=dynamic), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('superClass' type=dynamic), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 5, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undefined' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('window' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ], +} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js similarity index 100% rename from crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_app-6982cbb7db4140a2/input.js rename to crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug new file mode 100644 index 000000000000..12ec67f9931f --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug @@ -0,0 +1,388 @@ +TestSnapshot { + vars: [ + ( + ( + Atom('_N_E' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exec__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exports__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleId' type=dynamic), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: false, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('window' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ], +} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js similarity index 100% rename from crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/_error-04f03cfa2a163874/input.js rename to crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug new file mode 100644 index 000000000000..31a3e8806bfb --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug @@ -0,0 +1,7664 @@ +TestSnapshot { + vars: [ + ( + ( + Atom('ALL_INITIALIZERS' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Ace' type=inline), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Array' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Constructor' type=dynamic), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Constructor' type=dynamic), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Error' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Index' type=inline), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LazyImpl' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LazyImpl' type=dynamic), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Loadable' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableComponent' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableContext' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableImpl' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableImpl' type=dynamic), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableInitializer' type=dynamic), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableSubscription' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('LoadableSubscription' type=dynamic), + #35, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Loading' type=inline), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Object' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Promise' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('READY_INITIALIZERS' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Set' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('Symbol' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('TypeError' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_N_E' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_exports' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__unused_webpack_module' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exec__' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exports__' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_exports__' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #2, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_require__' type=dynamic), + #58, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('__webpack_unused_export__' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_classCallCheck' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_clearTimeouts' type=dynamic), + #42, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_createClass' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_default' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_defineProperties' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_defineProperty' type=static), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_defineProperty' type=static), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_didIteratorError' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_err' type=inline), + #39, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_instanceof' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_interopRequireDefault' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_interopRequireDefault' type=dynamic), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_interopRequireDefault' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_iterator' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_iteratorError' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_iteratorNormalCompletion' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_loadable' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_loadableContext' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_objectSpread' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_objectSpread' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_react' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_react' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_react' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_step' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this' type=inline), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this1' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_this2' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_update' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('_useSubscription' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('a' type=inline), + #56, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('arguments' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 3, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('b' type=inline), + #55, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('c' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 8, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #41, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('callback' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('clearTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('context' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('createLoadableComponent' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('d' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('descriptor' type=dynamic), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 7, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 7, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dynamic' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('dynamicOptions' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 6, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('e' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('err' type=inline), + #26, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('err' type=inline), + #34, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: true, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('error' type=inline), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #13, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('exports' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('f' type=inline), + #53, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 2, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('flushInitializers' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('g' type=inline), + #52, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('getCurrentValue' type=dynamic), + #43, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('h' type=inline), + #54, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('i' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ids' type=inline), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ids' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ids' type=inline), + #48, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('init' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('init' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('init' type=inline), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initialized' type=dynamic), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('initializers' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('instance' type=dynamic), + #16, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isLoading' type=dynamic), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('isServerSide' type=dynamic), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #8, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('key' type=static), + #22, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('left' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('load' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loadFn' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loadFn' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loadableFn' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loadableOptions' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 18, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 3, + mutation_by_call_count: 6, + usage_count: 15, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loadableOptions' type=dynamic), + #12, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loaded' type=inline), + #25, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('loader' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #51, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('module' type=static), + #57, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleId' type=dynamic), + #33, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleId' type=dynamic), + #59, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleIds' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('moduleName' type=dynamic), + #31, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('next_dynamic__WEBPACK_IMPORTED_MODULE_1__' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('noSSR' type=inline), + #3, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #11, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #14, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #23, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('obj' type=inline), + #27, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('options' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opts' type=inline), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 14, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 14, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opts' type=inline), + #36, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opts' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 5, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 5, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('opts' type=inline), + #45, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ownKeys' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ownKeys' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('param' type=inline), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('partial' type=inline), + #40, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('pastDelay' type=dynamic), + #10, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('promise' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('promise' type=inline), + #37, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('promises' type=dynamic), + #46, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('props' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('protoProps' type=dynamic), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__' type=dynamic), + #50, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ref' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ref' type=inline), + #32, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('ref' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('reject' type=inline), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('res' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('res' type=inline), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: true, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolve' type=inline), + #15, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolveInitializers' type=dynamic), + #47, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('resolvePreload' type=dynamic), + #49, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('retry' type=inline), + #38, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('right' type=inline), + #5, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('self' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: false, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('setTimeout' type=dynamic), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: true, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('source' type=inline), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('source' type=inline), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 4, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 3, + usage_count: 4, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #24, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 6, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('state' type=inline), + #30, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 9, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 9, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('staticProps' type=dynamic), + #18, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sub' type=inline), + #29, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 8, + cond_init: true, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 4, + usage_count: 8, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subscribe' type=dynamic), + #44, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 0, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: true, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 0, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: false, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: false, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('subscription' type=dynamic), + #28, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 6, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 1, + mutation_by_call_count: 2, + usage_count: 5, + reassigned_with_assignment: true, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('suspenseOptions' type=dynamic), + #9, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: Some( + "var", + ), + var_initialized: true, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sym' type=inline), + #7, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('sym' type=inline), + #21, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #6, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #17, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('target' type=static), + #20, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: true, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: true, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('undefined' type=static), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 1, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 1, + usage_count: 1, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #4, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('value' type=inline), + #19, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 2, + cond_init: false, + declared: true, + declared_count: 1, + declared_as_fn_param: true, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 2, + usage_count: 2, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: false, + has_property_mutation: false, + accessed_props: {}, + exported: false, + used_above_decl: false, + is_fn_local: true, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ( + ( + Atom('window' type=inline), + #1, + ), + VarUsageInfo { + inline_prevented: false, + ref_count: 3, + cond_init: false, + declared: false, + declared_count: 0, + declared_as_fn_param: false, + declared_as_fn_expr: false, + assign_count: 0, + mutation_by_call_count: 0, + usage_count: 3, + reassigned_with_assignment: false, + reassigned_with_var_decl: false, + mutated: true, + has_property_access: true, + has_property_mutation: true, + accessed_props: {}, + exported: false, + used_above_decl: true, + is_fn_local: false, + used_by_nested_fn: true, + executed_multiple_time: false, + used_in_cond: true, + var_kind: None, + var_initialized: false, + declared_as_catch_param: false, + no_side_effect_for_member_access: false, + used_as_callee: false, + used_as_arg: false, + pure_fn: false, + infects: [], + }, + ), + ], +} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js similarity index 100% rename from crates/swc_ecma_minifier/tests/compress/fixture/next/raw/static/chunks/pages/index-665b680df96552be/input.js rename to crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js From 5b54f0fb8ef1f5fedc4e214270f24b435e1087d0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 29 Mar 2022 18:39:57 +0900 Subject: [PATCH 3/5] Remove useless --- .../analysis-snapshot.rust-debug | 52684 ---------------- .../chunks/981.ed660b563826161d/input.js | 6573 -- .../analysis-snapshot.rust-debug | 4344 -- .../pages/_app-6982cbb7db4140a2/input.js | 226 - .../analysis-snapshot.rust-debug | 388 - .../pages/_error-04f03cfa2a163874/input.js | 25 - .../analysis-snapshot.rust-debug | 7664 --- .../pages/index-665b680df96552be/input.js | 588 - 8 files changed, 72492 deletions(-) delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug delete mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug deleted file mode 100644 index 13c207298145..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/analysis-snapshot.rust-debug +++ /dev/null @@ -1,52684 +0,0 @@ -TestSnapshot { - vars: [ - ( - ( - Atom('Array' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 17, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 9, - usage_count: 17, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ArrayBuffer' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Buffer' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('C' type=inline), - #237, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('COMPARE_PARTIAL_FLAG' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('COMPARE_UNORDERED_FLAG' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Ctor' type=inline), - #171, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Ctor' type=inline), - #175, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DIFF_DELETE' type=dynamic), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 27, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 27, - usage_count: 27, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DIFF_EQUAL' type=dynamic), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 41, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 41, - usage_count: 41, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DIFF_INSERT' type=dynamic), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 26, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 26, - usage_count: 26, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DataView' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Date' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DiffComponent' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DiffComponent' type=dynamic), - #232, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('DiffMatchPatch' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('EditSession' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Editor' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Error' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 14, - usage_count: 14, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('EventEmitter' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('FUNC_ERROR_TEXT' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Function' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('HASH_UNDEFINED' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('HASH_UNDEFINED' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Hash' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Hash' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('INFINITY' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LARGE_ARRAY_SIZE' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ListCache' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ListCache' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('MAX_SAFE_INTEGER' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Map' type=static), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Map' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('MapCache' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('MapCache' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Math' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 22, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 22, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Number' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Object' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 38, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 12, - usage_count: 38, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Promise' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('PropTypes' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 53, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 53, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('PropTypes' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 30, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 30, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('PropTypes' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 51, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 51, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('React' type=static), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('React' type=static), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('React' type=static), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactAce' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactAce' type=dynamic), - #201, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 23, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 23, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactIs' type=inline), - #192, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactPropTypes' type=dynamic), - #190, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactPropTypesSecret' type=dynamic), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReactPropTypesSecret' type=dynamic), - #193, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('RegExp' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Renderer' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Set' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('SetCache' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Split' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('SplitComponent' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('SplitComponent' type=dynamic), - #253, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 21, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 21, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Stack' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('String' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Symbol' type=static), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Symbol' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('TypeError' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Uint8Array' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('WeakMap' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__' type=inline), - #199, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__' type=inline), - #231, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__' type=inline), - #251, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__assign' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__assign' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__extends' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__extends' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__extends' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #192, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #192, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 19, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 19, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #218, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #219, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 19, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 19, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_a' type=inline), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_b' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_b' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_b' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_b' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_super' type=inline), - #201, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_super' type=inline), - #232, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_super' type=inline), - #253, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #202, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #221, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #233, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #254, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 15, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('a' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('a' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('accuracy' type=dynamic), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace' type=inline), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace' type=inline), - #242, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace' type=inline), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace_1' type=inline), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace_builds_1' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ace_builds_1' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('annotations' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('annotations' type=dynamic), - #206, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('annotations' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('appliedClasses' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('appliedClasses' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('appliedClassesArray_1' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('appliedClassesArray_1' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arg' type=inline), - #123, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('args' type=inline), - #102, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('args' type=inline), - #244, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('argsTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arguments' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrLength' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrValue' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #85, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #113, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #114, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #151, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('array' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayBufferTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayFilter' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayLikeKeys' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayProto' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayProto' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayPush' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arraySome' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arrayTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('assocIndexOf' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('assocIndexOf' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('asyncTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('availableOptions' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('availableOptions' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #196, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #197, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #198, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #199, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #228, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #229, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #230, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #231, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #248, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #249, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #250, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #251, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseGet' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseGetAllKeys' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseGetTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsArguments' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsEqual' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsEqualDeep' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsNative' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsNative' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseIsTypedArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseKeys' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseTimes' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseToString' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('baseUnary' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best' type=inline), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bestEdit' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bestEquality1' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bestEquality2' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bestScore' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_common' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_loc' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_longtext_a' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_longtext_b' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_shorttext_a' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('best_shorttext_b' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bigpatch' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 13, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bin_max' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bin_mid' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bin_min' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bitmask' type=inline), - #155, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bitmask' type=inline), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bitmask' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bitmask' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('bitmask' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('blankLine1' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('blankLine2' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('boolTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('cache' type=inline), - #102, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('cache' type=inline), - #118, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('cacheHas' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('callback' type=dynamic), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('castPath' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('changes' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('changes' type=inline), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('changes' type=inline), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('char1' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('char2' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('charMatch' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('char_count1' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('char_count2' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars' type=inline), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars1' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars1' type=inline), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars2' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chars2' type=inline), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('checklines' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('checklines' type=dynamic), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chunk' type=inline), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('chunkType' type=dynamic), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('className' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('className' type=dynamic), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('className' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('className' type=dynamic), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('clearTimeout' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('codeEditorSettings' type=dynamic), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('codeEditorSettings' type=dynamic), - #239, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('command' type=inline), - #208, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('command' type=inline), - #259, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commands' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commands' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonOffset' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonString' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonlength' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonlength' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonprefix' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('commonsuffix' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('compared' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('compared' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('componentName' type=dynamic), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('console' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('container' type=dynamic), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('context' type=inline), - #244, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('convert' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('coords1' type=inline), - #64, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('coords2' type=inline), - #64, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('coreJsData' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('coreJsData' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('count_delete' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('count_delete' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('count_insert' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('count_insert' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ctorString' type=dynamic), - #171, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('currentMarkers' type=dynamic), - #221, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 10, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('currentMarkers' type=dynamic), - #275, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('cursor' type=inline), - #237, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 16, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('cursorStart' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('customizer' type=dynamic), - #155, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('customizer' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('customizer' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('customizer' type=dynamic), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('customizer' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 10, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #196, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #197, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #198, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #199, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #228, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #229, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #230, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #231, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #248, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #249, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #250, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #251, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #72, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #73, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #74, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #76, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #77, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #79, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #90, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #129, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #130, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #131, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #133, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #134, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #136, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #141, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #145, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #146, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #149, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('data' type=inline), - #165, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dataViewCtorString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dataViewTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dateTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deadline' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deadline' type=dynamic), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deadline' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deadline' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deadline' type=dynamic), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('debounce' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('decodeURI' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('defaultValue' type=dynamic), - #109, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('defaultValue' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('defaultValue' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('defaultValueForEditor' type=dynamic), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('delay' type=inline), - #243, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deletion' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('deletions' type=dynamic), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('delta' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('delta' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('delta' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff' type=inline), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff' type=inline), - #237, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_1' type=inline), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_cleanupSemanticScore_' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_halfMatchI_' type=dynamic), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_linesToCharsMunge_' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_match_patch' type=dynamic), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 93, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 93, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_text' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_text' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 14, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_type' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diff_type' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffedLines' type=dynamic), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffedLines' type=dynamic), - #237, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffedLines' type=dynamic), - #239, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 11, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 23, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 23, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 12, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 47, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 47, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #45, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #48, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 3, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs' type=inline), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 19, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 18, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffsLength' type=dynamic), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs_a' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffs_b' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('diffsb' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('divStyle' type=dynamic), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('divStyle' type=dynamic), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dmp' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dmp' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dmp' type=inline), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('document' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #68, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #99, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #100, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #111, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #168, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #178, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #179, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('edit' type=inline), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 14, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #5, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 10, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #223, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 26, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 26, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 15, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #264, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #266, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #268, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #274, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editor' type=inline), - #275, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorEvents' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorHeight' type=dynamic), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorOptions' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorOptions_1' type=dynamic), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorOptions_1' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorProps' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorProps' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('editorWidth' type=dynamic), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('el' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('empty' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('emptyFunction' type=dynamic), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: true, - infects: [], - }, - ), - ( - ( - Atom('emptyFunctionWithReset' type=dynamic), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: true, - infects: [], - }, - ), - ( - ( - Atom('encodeURI' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('endCol' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('endCol' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('endRow' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('endRow' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('end_loc' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #70, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #75, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #80, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #127, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #132, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #137, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entries' type=inline), - #145, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #70, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #75, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #80, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #127, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #132, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('entry' type=inline), - #137, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('eq' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('eq' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalArrays' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalByTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalFunc' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalFunc' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalFunc' type=dynamic), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalFunc' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalObjects' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalities' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalities' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalitiesLength' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 3, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equalitiesLength' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 3, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equality1' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 5, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('equality2' type=dynamic), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 5, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('err' type=inline), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('errorTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #212, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #213, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #214, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #215, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #216, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #217, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #263, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #265, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #267, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #269, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #270, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('event' type=inline), - #271, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ex' type=inline), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ex' type=inline), - #63, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('expected_loc' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ext_split_1' type=dynamic), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('extendStatics' type=dynamic), - #195, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('extendStatics' type=dynamic), - #227, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('extendStatics' type=dynamic), - #247, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('extraLength' type=dynamic), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('finish' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('firstChar' type=dynamic), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('float32Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('float64Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('fn' type=inline), - #243, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('focus' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('focus' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('fontSize' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('fontSize' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('found' type=inline), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeExports' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeGlobal' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeGlobal' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeModule' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeProcess' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeSelf' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('freeSelf' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('front' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #94, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #98, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #101, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #116, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #122, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #174, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('func' type=inline), - #177, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcProto' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcProto' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcTag' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcToString' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('funcToString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('genTag' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('genTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('get' type=static), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('get' type=static), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getAceInstance' type=dynamic), - #241, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getAllKeys' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getMapData' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getMapData' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getNative' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getNative' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getRawTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getShim' type=inline), - #190, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getSymbols' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getValue' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getValue' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hasOwnProperty' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hasOwnProperty' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashClear' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashClear' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashDelete' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashDelete' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashGet' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashGet' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashHas' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashHas' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashSet' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hashSet' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('height' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('height' type=inline), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('height' type=inline), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hm' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hm' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 0, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hm1' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hm2' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('html' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: true, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #200, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #221, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #239, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 4, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: true, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #252, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 4, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: true, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #275, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('idx' type=inline), - #8, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('idx' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('inFront' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('inFront' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #70, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #75, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #76, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #77, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #79, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #80, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #86, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #113, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #114, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #115, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #120, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #124, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #127, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #132, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #133, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #134, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #136, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #137, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #142, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #210, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index' type=inline), - #262, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index1' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('index2' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('inherited' type=dynamic), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('insertion' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('insertions' type=dynamic), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('int16Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('int32Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('int8Tag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArg' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArguments' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArr' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArray' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArray' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isArrayLike' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isBuff' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isBuffer' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isEqual' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isEqual' type=inline), - #194, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isEqual' type=inline), - #246, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isFunction' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isFunction' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isHostObject' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isIndex' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isKey' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isKeyable' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isKeyable' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isLength' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isMasked' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isMasked' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isNaN' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isObject' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isObject' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isObjectLike' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isObjectLike' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isOwn' type=inline), - #167, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isPartial' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isPartial' type=dynamic), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isPartial' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isPrototype' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isSameTag' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isSymbol' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isType' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isTypedArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isUsed' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('item' type=inline), - #224, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('item' type=inline), - #277, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('iteratee' type=dynamic), - #115, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('j' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('j' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('j' type=inline), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('j' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 5, - usage_count: 13, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k1' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k1_offset' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 11, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k1end' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k1start' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k2' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k2_offset' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k2end' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('k2start' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #66, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #71, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #72, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #73, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #74, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #76, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #77, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #78, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #79, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #81, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #82, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #83, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #84, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #85, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #90, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #91, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #102, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #118, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #119, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #121, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #128, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #129, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #130, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #131, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #133, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #134, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #135, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #136, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #138, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #139, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #140, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #141, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #146, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #147, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #148, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #149, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #151, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #159, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 5, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #165, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #166, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('keybinding' type=dynamic), - #11, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('keyboardHandler' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('keyboardHandler' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('keys' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('keysFunc' type=dynamic), - #152, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lang' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lastChar' type=dynamic), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lastEquality' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lastEquality' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lastIndex' type=dynamic), - #76, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lastIndex' type=dynamic), - #133, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('last_chars1' type=dynamic), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('last_chars2' type=dynamic), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('last_rd' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 5, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #70, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #75, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #80, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #85, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #86, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #113, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #114, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #127, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #132, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #137, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #142, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #151, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length' type=static), - #172, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length_deletions1' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length_deletions2' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length_insertions1' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('length_insertions2' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('levenshtein' type=dynamic), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lhString' type=dynamic), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('line' type=inline), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('line' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineArray' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineArray' type=dynamic), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineArrayLength' type=dynamic), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineBreak1' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineBreak2' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineEnd' type=inline), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineHash' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lineStart' type=dynamic), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('linearray' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('lines' type=inline), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 8, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('linesToHighlight' type=dynamic), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 4, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheClear' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheClear' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheDelete' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheDelete' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheGet' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheGet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheHas' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheHas' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheSet' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('listCacheSet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loc' type=inline), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loc' type=inline), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loc' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 9, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('location' type=dynamic), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('longtext' type=dynamic), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('longtext' type=dynamic), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('longtext' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('m' type=inline), - #22, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('m' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('map' type=inline), - #90, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('map' type=inline), - #120, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('map' type=inline), - #165, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheClear' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheClear' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheDelete' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheDelete' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheGet' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheGet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheHas' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheHas' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheSet' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCacheSet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapCtorString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mapToArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('margins' type=inline), - #211, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markerObj' type=dynamic), - #239, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markers' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markers' type=inline), - #221, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markers' type=inline), - #240, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markers' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('markers' type=inline), - #275, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('maskSrcKey' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('maskSrcKey' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('match' type=inline), - #96, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('match_bitapScore_' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('matchmask' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('maxLines' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('max_d' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('memoize' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('memoized' type=dynamic), - #101, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('method' type=inline), - #203, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('method' type=inline), - #255, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mid_common' type=dynamic), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mid_common' type=dynamic), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mod' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mode' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('mode' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #189, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #192, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #193, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleExports' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('n' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('n' type=inline), - #115, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('n' type=inline), - #200, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('n' type=inline), - #252, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('name' type=inline), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('name' type=inline), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeCreate' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeCreate' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeGetSymbols' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeIsBuffer' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeKeys' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nativeObjectToString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('newAnnotations' type=dynamic), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('newAnnotations' type=dynamic), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('newMarkerSet' type=dynamic), - #239, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('newMarkers' type=dynamic), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('newMarkers' type=dynamic), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nextProps' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 37, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 37, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nextProps' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 32, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 32, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nextValue' type=dynamic), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('node' type=inline), - #204, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('node' type=inline), - #223, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 10, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('node' type=inline), - #256, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nodeIsTypedArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nodeUtil' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nonAlphaNumeric1' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nonAlphaNumeric2' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nullPadding' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nullPadding' type=dynamic), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('nullTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('number' type=static), - #96, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('numberTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objCtor' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objIsArr' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objIsObj' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objIsWrapped' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objLength' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objProps' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objTag' type=inline), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objUnwrapped' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objValue' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #66, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #86, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #91, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #92, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #109, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #119, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #152, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 9, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #159, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 8, - usage_count: 15, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 8, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #164, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #166, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #169, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('object' type=static), - #188, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objectProto' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objectProto' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objectTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objectToString' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('objectToString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('offset' type=inline), - #113, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldAnnotations' type=dynamic), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldClass' type=dynamic), - #210, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldClass' type=dynamic), - #262, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldClassesArray' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldClassesArray' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldMarkers' type=dynamic), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldProps' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 15, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oldProps' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 16, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('onBeforeLoad' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('onBeforeLoad' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('onLoad' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('onLoad' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('onValidate' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('one' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('oop' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('op' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('op' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('op' type=inline), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('op' type=inline), - #64, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opt_b' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opt_c' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opt_checklines' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opt_deadline' type=dynamic), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('option' type=inline), - #207, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('option' type=inline), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('option' type=inline), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('option' type=inline), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('orientation' type=dynamic), - #19, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othCtor' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othIndex' type=dynamic), - #161, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othIsArr' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othIsObj' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othIsWrapped' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othLength' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othLength' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othProps' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othTag' type=inline), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othUnwrapped' type=dynamic), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othValue' type=dynamic), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othValue' type=dynamic), - #161, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('othValue' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #103, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #155, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 8, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 8, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 7, - usage_count: 14, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 11, - usage_count: 13, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #180, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('other' type=inline), - #183, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('overArg' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('overlap_length1' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('overlap_length2' type=dynamic), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #198, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #200, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #230, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #250, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #252, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('padding' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 4, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('paddingLength' type=dynamic), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 13, - usage_count: 13, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pairs' type=inline), - #149, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('param' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('parent' type=inline), - #204, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('parent' type=inline), - #256, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('parseInt' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 19, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 19, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 13, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 14, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 26, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 26, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 20, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 20, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patchCopy' type=dynamic), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patchDiffLength' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 4, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patchHeader' type=dynamic), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patch_size' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #61, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patches' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('patchesCopy' type=dynamic), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('path' type=inline), - #86, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('path' type=inline), - #109, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #87, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern' type=inline), - #157, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern_amp' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern_gt' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern_lt' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pattern_para' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('placeholder' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('placeholder' type=dynamic), - #223, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 6, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 32, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 7, - mutation_by_call_count: 10, - usage_count: 25, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 18, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 6, - usage_count: 15, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 61, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 10, - mutation_by_call_count: 18, - usage_count: 52, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointer' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointerend' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermax' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermax' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermid' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermid' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermin' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointermin' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pointerstart' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pos' type=inline), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pos' type=inline), - #261, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('post_del' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('post_ins' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('postcontext' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('postpatch_text' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pre_del' type=inline), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pre_ins' type=inline), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('precontext' type=dynamic), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('predicate' type=dynamic), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('predicate' type=dynamic), - #114, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('prefix' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('prefixLength' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('prepatch_text' type=dynamic), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('prevProps' type=dynamic), - #209, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('prevProps' type=dynamic), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('promiseCtorString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('promiseTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('propFullName' type=dynamic), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('propName' type=dynamic), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('propertyIsEnumerable' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #202, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #220, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #233, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #254, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #274, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('proto' type=inline), - #175, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('proximity' type=dynamic), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('proxyTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('quote' type=inline), - #96, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('range' type=inline), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('range' type=inline), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('rd' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reEscapeChar' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsDeepProp' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsHostCtor' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsHostCtor' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsNative' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsNative' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsPlainProp' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reIsUint' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reLeadingDot' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('rePropName' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reRegExpChar' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reRegExpChar' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('regexpTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('require' type=static), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('require' type=static), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resIndex' type=dynamic), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolver' type=dynamic), - #101, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #67, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #72, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #88, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #95, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #97, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #102, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #109, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #115, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #120, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #124, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #128, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #129, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #138, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #146, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #152, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #159, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #167, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #171, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('results' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('rhString' type=dynamic), - #236, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('root' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('root' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('s' type=inline), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('s' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('s' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('s' type=inline), - #200, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('s' type=inline), - #252, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('scope' type=inline), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('score' type=inline), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('score' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('score_threshold' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('scrollMargin' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('scrollMargin' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('secret' type=inline), - #191, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('seed' type=inline), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('seen' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('session' type=inline), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 12, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('session' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('set' type=static), - #124, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setCacheAdd' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setCacheHas' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setCtorString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setOptions' type=dynamic), - #220, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setOptions' type=dynamic), - #274, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setTag' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setTimeout' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setToArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('shim' type=inline), - #190, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 14, - usage_count: 15, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('shorttext' type=dynamic), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('shorttext' type=dynamic), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('shorttext' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('showGutter' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('showGutter' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('showPlaceholder' type=dynamic), - #223, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('showPrintMargin' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('showPrintMargin' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('sign' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('size' type=inline), - #14, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('size' type=inline), - #141, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('skipCtor' type=dynamic), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('skipIndexes' type=dynamic), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('sp' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('splice' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('splice' type=inline), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('split' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('split' type=inline), - #260, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('split_1' type=inline), - #226, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('split_1' type=inline), - #245, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('splits' type=inline), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('splits' type=inline), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('splits' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stack' type=inline), - #155, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stack' type=inline), - #156, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stack' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stack' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stack' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stackClear' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stackDelete' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stackGet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stackHas' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stackSet' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stacked' type=inline), - #160, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stacked' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stacked' type=inline), - #163, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('start' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('start1' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('start2' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('startCol' type=dynamic), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('startCol' type=dynamic), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('startRow' type=dynamic), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('startRow' type=dynamic), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('start_loc' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 16, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 13, - usage_count: 13, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('string' type=static), - #95, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('string' type=static), - #96, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stringTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stringToPath' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stubArray' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('stubFalse' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('style' type=inline), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('style' type=inline), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('subDiff' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('suffix' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('suffixLength' type=dynamic), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symToStringTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbol' type=static), - #170, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolProto' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolProto' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolTag' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolToString' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolValueOf' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('symbolsFunc' type=dynamic), - #152, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('t' type=inline), - #200, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('t' type=inline), - #252, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('tag' type=inline), - #104, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('tag' type=inline), - #162, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('tag' type=inline), - #167, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('tag' type=inline), - #184, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #45, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #48, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 21, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 6, - usage_count: 16, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #61, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #64, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #218, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #219, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #238, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #272, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text' type=inline), - #273, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 7, - usage_count: 13, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 8, - usage_count: 12, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 12, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_a' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_a' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_b' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_b' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_length' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 9, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1_length' type=dynamic), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1a' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text1b' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 5, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 12, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 8, - usage_count: 12, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_a' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_a' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_b' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_b' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_length' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2_length' type=dynamic), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2a' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text2b' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('textPointer' type=dynamic), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 4, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text_delete' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text_delete' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 11, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 3, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text_insert' type=dynamic), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text_insert' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 15, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 3, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('text_length' type=dynamic), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('textline' type=dynamic), - #62, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('theme' type=inline), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('theme' type=inline), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('theme' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('theme' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('throwOnDirectAccess' type=dynamic), - #192, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('timer' type=inline), - #243, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('toKey' type=inline), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('toSource' type=dynamic), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('toSource' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('toString' type=static), - #65, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('tokens' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('transform' type=dynamic), - #122, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('two' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #92, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #93, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #105, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #173, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #186, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #222, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('type' type=static), - #276, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('typedArrayTags' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 25, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 25, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uid' type=inline), - #69, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uid' type=inline), - #126, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uint16Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uint32Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uint8ClampedTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('uint8Tag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('undefined' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 32, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 32, - usage_count: 32, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('undefinedTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('undoManager' type=dynamic), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('unmasked' type=dynamic), - #167, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('v1' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('v2' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('v_length' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('v_offset' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 5, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #67, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #74, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #79, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #84, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #87, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #88, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #89, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #91, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #92, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #93, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #97, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #103, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #104, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #105, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #106, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #107, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #108, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #112, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #117, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #121, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #125, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #131, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #136, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #141, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #143, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #144, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #149, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #150, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 7, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #153, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #154, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #155, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #157, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #158, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #166, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #167, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #171, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #172, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #173, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #175, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #176, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #180, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #181, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #182, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #183, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #184, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #185, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #186, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #187, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #212, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #213, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #214, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #234, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #235, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('valueForEditor' type=dynamic), - #258, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value_1' type=inline), - #263, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value_2' type=inline), - #265, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value_3' type=inline), - #267, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('values' type=inline), - #113, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('values' type=inline), - #142, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('weakMapCtorString' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('weakMapTag' type=dynamic), - #110, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('whitespace1' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('whitespace2' type=dynamic), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('width' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('width' type=inline), - #225, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('width' type=inline), - #278, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('window' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('wrapEnabled' type=dynamic), - #205, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('wrapEnabled' type=dynamic), - #257, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 3, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #45, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #48, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 9, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 3, - usage_count: 8, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 5, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: true, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #60, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 4, - usage_count: 6, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #61, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x' type=inline), - #64, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x1' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 4, - mutation_by_call_count: 11, - usage_count: 12, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('x2' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 13, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 5, - mutation_by_call_count: 9, - usage_count: 10, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y' type=inline), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y' type=inline), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y' type=inline), - #220, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y' type=inline), - #274, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y1' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 2, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 6, - usage_count: 7, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('y2' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ], -} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js deleted file mode 100644 index 2ed289e8f201..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/981.ed660b563826161d/input.js +++ /dev/null @@ -1,6573 +0,0 @@ -(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[981],{ - -/***/ 3083: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -/* module decorator */ module = __webpack_require__.nmd(module); -ace.define("ace/split",["require","exports","module","ace/lib/oop","ace/lib/lang","ace/lib/event_emitter","ace/editor","ace/virtual_renderer","ace/edit_session"], function(require, exports, module) { -"use strict"; - -var oop = require("./lib/oop"); -var lang = require("./lib/lang"); -var EventEmitter = require("./lib/event_emitter").EventEmitter; - -var Editor = require("./editor").Editor; -var Renderer = require("./virtual_renderer").VirtualRenderer; -var EditSession = require("./edit_session").EditSession; - - -var Split = function(container, theme, splits) { - this.BELOW = 1; - this.BESIDE = 0; - - this.$container = container; - this.$theme = theme; - this.$splits = 0; - this.$editorCSS = ""; - this.$editors = []; - this.$orientation = this.BESIDE; - - this.setSplits(splits || 1); - this.$cEditor = this.$editors[0]; - - - this.on("focus", function(editor) { - this.$cEditor = editor; - }.bind(this)); -}; - -(function(){ - - oop.implement(this, EventEmitter); - - this.$createEditor = function() { - var el = document.createElement("div"); - el.className = this.$editorCSS; - el.style.cssText = "position: absolute; top:0px; bottom:0px"; - this.$container.appendChild(el); - var editor = new Editor(new Renderer(el, this.$theme)); - - editor.on("focus", function() { - this._emit("focus", editor); - }.bind(this)); - - this.$editors.push(editor); - editor.setFontSize(this.$fontSize); - return editor; - }; - - this.setSplits = function(splits) { - var editor; - if (splits < 1) { - throw "The number of splits have to be > 0!"; - } - - if (splits == this.$splits) { - return; - } else if (splits > this.$splits) { - while (this.$splits < this.$editors.length && this.$splits < splits) { - editor = this.$editors[this.$splits]; - this.$container.appendChild(editor.container); - editor.setFontSize(this.$fontSize); - this.$splits ++; - } - while (this.$splits < splits) { - this.$createEditor(); - this.$splits ++; - } - } else { - while (this.$splits > splits) { - editor = this.$editors[this.$splits - 1]; - this.$container.removeChild(editor.container); - this.$splits --; - } - } - this.resize(); - }; - this.getSplits = function() { - return this.$splits; - }; - this.getEditor = function(idx) { - return this.$editors[idx]; - }; - this.getCurrentEditor = function() { - return this.$cEditor; - }; - this.focus = function() { - this.$cEditor.focus(); - }; - this.blur = function() { - this.$cEditor.blur(); - }; - this.setTheme = function(theme) { - this.$editors.forEach(function(editor) { - editor.setTheme(theme); - }); - }; - this.setKeyboardHandler = function(keybinding) { - this.$editors.forEach(function(editor) { - editor.setKeyboardHandler(keybinding); - }); - }; - this.forEach = function(callback, scope) { - this.$editors.forEach(callback, scope); - }; - - - this.$fontSize = ""; - this.setFontSize = function(size) { - this.$fontSize = size; - this.forEach(function(editor) { - editor.setFontSize(size); - }); - }; - - this.$cloneSession = function(session) { - var s = new EditSession(session.getDocument(), session.getMode()); - - var undoManager = session.getUndoManager(); - s.setUndoManager(undoManager); - s.setTabSize(session.getTabSize()); - s.setUseSoftTabs(session.getUseSoftTabs()); - s.setOverwrite(session.getOverwrite()); - s.setBreakpoints(session.getBreakpoints()); - s.setUseWrapMode(session.getUseWrapMode()); - s.setUseWorker(session.getUseWorker()); - s.setWrapLimitRange(session.$wrapLimitRange.min, - session.$wrapLimitRange.max); - s.$foldData = session.$cloneFoldData(); - - return s; - }; - this.setSession = function(session, idx) { - var editor; - if (idx == null) { - editor = this.$cEditor; - } else { - editor = this.$editors[idx]; - } - var isUsed = this.$editors.some(function(editor) { - return editor.session === session; - }); - - if (isUsed) { - session = this.$cloneSession(session); - } - editor.setSession(session); - return session; - }; - this.getOrientation = function() { - return this.$orientation; - }; - this.setOrientation = function(orientation) { - if (this.$orientation == orientation) { - return; - } - this.$orientation = orientation; - this.resize(); - }; - this.resize = function() { - var width = this.$container.clientWidth; - var height = this.$container.clientHeight; - var editor; - - if (this.$orientation == this.BESIDE) { - var editorWidth = width / this.$splits; - for (var i = 0; i < this.$splits; i++) { - editor = this.$editors[i]; - editor.container.style.width = editorWidth + "px"; - editor.container.style.top = "0px"; - editor.container.style.left = i * editorWidth + "px"; - editor.container.style.height = height + "px"; - editor.resize(); - } - } else { - var editorHeight = height / this.$splits; - for (var i = 0; i < this.$splits; i++) { - editor = this.$editors[i]; - editor.container.style.width = width + "px"; - editor.container.style.top = i * editorHeight + "px"; - editor.container.style.left = "0px"; - editor.container.style.height = editorHeight + "px"; - editor.resize(); - } - } - }; - -}).call(Split.prototype); - -exports.Split = Split; -}); - -ace.define("ace/ext/split",["require","exports","module","ace/split"], function(require, exports, module) { -"use strict"; -module.exports = require("../split"); - -}); (function() { - ace.require(["ace/ext/split"], function(m) { - if ( true && module) { - module.exports = m; - } - }); - })(); - - -/***/ }), - -/***/ 2027: -/***/ (function(module) { - -/** - * Diff Match and Patch - * Copyright 2018 The diff-match-patch Authors. - * https://github.com/google/diff-match-patch - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** - * @fileoverview Computes the difference between two texts to create a patch. - * Applies the patch onto another text, allowing for errors. - * @author fraser@google.com (Neil Fraser) - */ - -/** - * Class containing the diff, match and patch methods. - * @constructor - */ -var diff_match_patch = function() { - - // Defaults. - // Redefine these in your program to override the defaults. - - // Number of seconds to map a diff before giving up (0 for infinity). - this.Diff_Timeout = 1.0; - // Cost of an empty edit operation in terms of edit characters. - this.Diff_EditCost = 4; - // At what point is no match declared (0.0 = perfection, 1.0 = very loose). - this.Match_Threshold = 0.5; - // How far to search for a match (0 = exact location, 1000+ = broad match). - // A match this many characters away from the expected location will add - // 1.0 to the score (0.0 is a perfect match). - this.Match_Distance = 1000; - // When deleting a large block of text (over ~64 characters), how close do - // the contents have to be to match the expected contents. (0.0 = perfection, - // 1.0 = very loose). Note that Match_Threshold controls how closely the - // end points of a delete need to match. - this.Patch_DeleteThreshold = 0.5; - // Chunk size for context length. - this.Patch_Margin = 4; - - // The number of bits in an int. - this.Match_MaxBits = 32; -}; - - -// DIFF FUNCTIONS - - -/** - * The data structure representing a diff is an array of tuples: - * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']] - * which means: delete 'Hello', add 'Goodbye' and keep ' world.' - */ -var DIFF_DELETE = -1; -var DIFF_INSERT = 1; -var DIFF_EQUAL = 0; - -/** - * Class representing one diff tuple. - * ~Attempts to look like a two-element array (which is what this used to be).~ - * Constructor returns an actual two-element array, to allow destructing @JackuB - * See https://github.com/JackuB/diff-match-patch/issues/14 for details - * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL. - * @param {string} text Text to be deleted, inserted, or retained. - * @constructor - */ -diff_match_patch.Diff = function(op, text) { - return [op, text]; -}; - -/** - * Find the differences between two texts. Simplifies the problem by stripping - * any common prefix or suffix off the texts before diffing. - * @param {string} text1 Old string to be diffed. - * @param {string} text2 New string to be diffed. - * @param {boolean=} opt_checklines Optional speedup flag. If present and false, - * then don't run a line-level diff first to identify the changed areas. - * Defaults to true, which does a faster, slightly less optimal diff. - * @param {number=} opt_deadline Optional time when the diff should be complete - * by. Used internally for recursive calls. Users should set DiffTimeout - * instead. - * @return {!Array.} Array of diff tuples. - */ -diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines, - opt_deadline) { - // Set a deadline by which time the diff must be complete. - if (typeof opt_deadline == 'undefined') { - if (this.Diff_Timeout <= 0) { - opt_deadline = Number.MAX_VALUE; - } else { - opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000; - } - } - var deadline = opt_deadline; - - // Check for null inputs. - if (text1 == null || text2 == null) { - throw new Error('Null input. (diff_main)'); - } - - // Check for equality (speedup). - if (text1 == text2) { - if (text1) { - return [new diff_match_patch.Diff(DIFF_EQUAL, text1)]; - } - return []; - } - - if (typeof opt_checklines == 'undefined') { - opt_checklines = true; - } - var checklines = opt_checklines; - - // Trim off common prefix (speedup). - var commonlength = this.diff_commonPrefix(text1, text2); - var commonprefix = text1.substring(0, commonlength); - text1 = text1.substring(commonlength); - text2 = text2.substring(commonlength); - - // Trim off common suffix (speedup). - commonlength = this.diff_commonSuffix(text1, text2); - var commonsuffix = text1.substring(text1.length - commonlength); - text1 = text1.substring(0, text1.length - commonlength); - text2 = text2.substring(0, text2.length - commonlength); - - // Compute the diff on the middle block. - var diffs = this.diff_compute_(text1, text2, checklines, deadline); - - // Restore the prefix and suffix. - if (commonprefix) { - diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix)); - } - if (commonsuffix) { - diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix)); - } - this.diff_cleanupMerge(diffs); - return diffs; -}; - - -/** - * Find the differences between two texts. Assumes that the texts do not - * have any common prefix or suffix. - * @param {string} text1 Old string to be diffed. - * @param {string} text2 New string to be diffed. - * @param {boolean} checklines Speedup flag. If false, then don't run a - * line-level diff first to identify the changed areas. - * If true, then run a faster, slightly less optimal diff. - * @param {number} deadline Time when the diff should be complete by. - * @return {!Array.} Array of diff tuples. - * @private - */ -diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines, - deadline) { - var diffs; - - if (!text1) { - // Just add some text (speedup). - return [new diff_match_patch.Diff(DIFF_INSERT, text2)]; - } - - if (!text2) { - // Just delete some text (speedup). - return [new diff_match_patch.Diff(DIFF_DELETE, text1)]; - } - - var longtext = text1.length > text2.length ? text1 : text2; - var shorttext = text1.length > text2.length ? text2 : text1; - var i = longtext.indexOf(shorttext); - if (i != -1) { - // Shorter text is inside the longer text (speedup). - diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)), - new diff_match_patch.Diff(DIFF_EQUAL, shorttext), - new diff_match_patch.Diff(DIFF_INSERT, - longtext.substring(i + shorttext.length))]; - // Swap insertions for deletions if diff is reversed. - if (text1.length > text2.length) { - diffs[0][0] = diffs[2][0] = DIFF_DELETE; - } - return diffs; - } - - if (shorttext.length == 1) { - // Single character string. - // After the previous speedup, the character can't be an equality. - return [new diff_match_patch.Diff(DIFF_DELETE, text1), - new diff_match_patch.Diff(DIFF_INSERT, text2)]; - } - - // Check to see if the problem can be split in two. - var hm = this.diff_halfMatch_(text1, text2); - if (hm) { - // A half-match was found, sort out the return data. - var text1_a = hm[0]; - var text1_b = hm[1]; - var text2_a = hm[2]; - var text2_b = hm[3]; - var mid_common = hm[4]; - // Send both pairs off for separate processing. - var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline); - var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline); - // Merge the results. - return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)], - diffs_b); - } - - if (checklines && text1.length > 100 && text2.length > 100) { - return this.diff_lineMode_(text1, text2, deadline); - } - - return this.diff_bisect_(text1, text2, deadline); -}; - - -/** - * Do a quick line-level diff on both strings, then rediff the parts for - * greater accuracy. - * This speedup can produce non-minimal diffs. - * @param {string} text1 Old string to be diffed. - * @param {string} text2 New string to be diffed. - * @param {number} deadline Time when the diff should be complete by. - * @return {!Array.} Array of diff tuples. - * @private - */ -diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) { - // Scan the text on a line-by-line basis first. - var a = this.diff_linesToChars_(text1, text2); - text1 = a.chars1; - text2 = a.chars2; - var linearray = a.lineArray; - - var diffs = this.diff_main(text1, text2, false, deadline); - - // Convert the diff back to original text. - this.diff_charsToLines_(diffs, linearray); - // Eliminate freak matches (e.g. blank lines) - this.diff_cleanupSemantic(diffs); - - // Rediff any replacement blocks, this time character-by-character. - // Add a dummy entry at the end. - diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, '')); - var pointer = 0; - var count_delete = 0; - var count_insert = 0; - var text_delete = ''; - var text_insert = ''; - while (pointer < diffs.length) { - switch (diffs[pointer][0]) { - case DIFF_INSERT: - count_insert++; - text_insert += diffs[pointer][1]; - break; - case DIFF_DELETE: - count_delete++; - text_delete += diffs[pointer][1]; - break; - case DIFF_EQUAL: - // Upon reaching an equality, check for prior redundancies. - if (count_delete >= 1 && count_insert >= 1) { - // Delete the offending records and add the merged ones. - diffs.splice(pointer - count_delete - count_insert, - count_delete + count_insert); - pointer = pointer - count_delete - count_insert; - var subDiff = - this.diff_main(text_delete, text_insert, false, deadline); - for (var j = subDiff.length - 1; j >= 0; j--) { - diffs.splice(pointer, 0, subDiff[j]); - } - pointer = pointer + subDiff.length; - } - count_insert = 0; - count_delete = 0; - text_delete = ''; - text_insert = ''; - break; - } - pointer++; - } - diffs.pop(); // Remove the dummy entry at the end. - - return diffs; -}; - - -/** - * Find the 'middle snake' of a diff, split the problem in two - * and return the recursively constructed diff. - * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations. - * @param {string} text1 Old string to be diffed. - * @param {string} text2 New string to be diffed. - * @param {number} deadline Time at which to bail if not yet complete. - * @return {!Array.} Array of diff tuples. - * @private - */ -diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) { - // Cache the text lengths to prevent multiple calls. - var text1_length = text1.length; - var text2_length = text2.length; - var max_d = Math.ceil((text1_length + text2_length) / 2); - var v_offset = max_d; - var v_length = 2 * max_d; - var v1 = new Array(v_length); - var v2 = new Array(v_length); - // Setting all elements to -1 is faster in Chrome & Firefox than mixing - // integers and undefined. - for (var x = 0; x < v_length; x++) { - v1[x] = -1; - v2[x] = -1; - } - v1[v_offset + 1] = 0; - v2[v_offset + 1] = 0; - var delta = text1_length - text2_length; - // If the total number of characters is odd, then the front path will collide - // with the reverse path. - var front = (delta % 2 != 0); - // Offsets for start and end of k loop. - // Prevents mapping of space beyond the grid. - var k1start = 0; - var k1end = 0; - var k2start = 0; - var k2end = 0; - for (var d = 0; d < max_d; d++) { - // Bail out if deadline is reached. - if ((new Date()).getTime() > deadline) { - break; - } - - // Walk the front path one step. - for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) { - var k1_offset = v_offset + k1; - var x1; - if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) { - x1 = v1[k1_offset + 1]; - } else { - x1 = v1[k1_offset - 1] + 1; - } - var y1 = x1 - k1; - while (x1 < text1_length && y1 < text2_length && - text1.charAt(x1) == text2.charAt(y1)) { - x1++; - y1++; - } - v1[k1_offset] = x1; - if (x1 > text1_length) { - // Ran off the right of the graph. - k1end += 2; - } else if (y1 > text2_length) { - // Ran off the bottom of the graph. - k1start += 2; - } else if (front) { - var k2_offset = v_offset + delta - k1; - if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) { - // Mirror x2 onto top-left coordinate system. - var x2 = text1_length - v2[k2_offset]; - if (x1 >= x2) { - // Overlap detected. - return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); - } - } - } - } - - // Walk the reverse path one step. - for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) { - var k2_offset = v_offset + k2; - var x2; - if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) { - x2 = v2[k2_offset + 1]; - } else { - x2 = v2[k2_offset - 1] + 1; - } - var y2 = x2 - k2; - while (x2 < text1_length && y2 < text2_length && - text1.charAt(text1_length - x2 - 1) == - text2.charAt(text2_length - y2 - 1)) { - x2++; - y2++; - } - v2[k2_offset] = x2; - if (x2 > text1_length) { - // Ran off the left of the graph. - k2end += 2; - } else if (y2 > text2_length) { - // Ran off the top of the graph. - k2start += 2; - } else if (!front) { - var k1_offset = v_offset + delta - k2; - if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) { - var x1 = v1[k1_offset]; - var y1 = v_offset + x1 - k1_offset; - // Mirror x2 onto top-left coordinate system. - x2 = text1_length - x2; - if (x1 >= x2) { - // Overlap detected. - return this.diff_bisectSplit_(text1, text2, x1, y1, deadline); - } - } - } - } - } - // Diff took too long and hit the deadline or - // number of diffs equals number of characters, no commonality at all. - return [new diff_match_patch.Diff(DIFF_DELETE, text1), - new diff_match_patch.Diff(DIFF_INSERT, text2)]; -}; - - -/** - * Given the location of the 'middle snake', split the diff in two parts - * and recurse. - * @param {string} text1 Old string to be diffed. - * @param {string} text2 New string to be diffed. - * @param {number} x Index of split point in text1. - * @param {number} y Index of split point in text2. - * @param {number} deadline Time at which to bail if not yet complete. - * @return {!Array.} Array of diff tuples. - * @private - */ -diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y, - deadline) { - var text1a = text1.substring(0, x); - var text2a = text2.substring(0, y); - var text1b = text1.substring(x); - var text2b = text2.substring(y); - - // Compute both diffs serially. - var diffs = this.diff_main(text1a, text2a, false, deadline); - var diffsb = this.diff_main(text1b, text2b, false, deadline); - - return diffs.concat(diffsb); -}; - - -/** - * Split two texts into an array of strings. Reduce the texts to a string of - * hashes where each Unicode character represents one line. - * @param {string} text1 First string. - * @param {string} text2 Second string. - * @return {{chars1: string, chars2: string, lineArray: !Array.}} - * An object containing the encoded text1, the encoded text2 and - * the array of unique strings. - * The zeroth element of the array of unique strings is intentionally blank. - * @private - */ -diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) { - var lineArray = []; // e.g. lineArray[4] == 'Hello\n' - var lineHash = {}; // e.g. lineHash['Hello\n'] == 4 - - // '\x00' is a valid character, but various debuggers don't like it. - // So we'll insert a junk entry to avoid generating a null character. - lineArray[0] = ''; - - /** - * Split a text into an array of strings. Reduce the texts to a string of - * hashes where each Unicode character represents one line. - * Modifies linearray and linehash through being a closure. - * @param {string} text String to encode. - * @return {string} Encoded string. - * @private - */ - function diff_linesToCharsMunge_(text) { - var chars = ''; - // Walk the text, pulling out a substring for each line. - // text.split('\n') would would temporarily double our memory footprint. - // Modifying text would create many large strings to garbage collect. - var lineStart = 0; - var lineEnd = -1; - // Keeping our own length variable is faster than looking it up. - var lineArrayLength = lineArray.length; - while (lineEnd < text.length - 1) { - lineEnd = text.indexOf('\n', lineStart); - if (lineEnd == -1) { - lineEnd = text.length - 1; - } - var line = text.substring(lineStart, lineEnd + 1); - - if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) : - (lineHash[line] !== undefined)) { - chars += String.fromCharCode(lineHash[line]); - } else { - if (lineArrayLength == maxLines) { - // Bail out at 65535 because - // String.fromCharCode(65536) == String.fromCharCode(0) - line = text.substring(lineStart); - lineEnd = text.length; - } - chars += String.fromCharCode(lineArrayLength); - lineHash[line] = lineArrayLength; - lineArray[lineArrayLength++] = line; - } - lineStart = lineEnd + 1; - } - return chars; - } - // Allocate 2/3rds of the space for text1, the rest for text2. - var maxLines = 40000; - var chars1 = diff_linesToCharsMunge_(text1); - maxLines = 65535; - var chars2 = diff_linesToCharsMunge_(text2); - return {chars1: chars1, chars2: chars2, lineArray: lineArray}; -}; - - -/** - * Rehydrate the text in a diff from a string of line hashes to real lines of - * text. - * @param {!Array.} diffs Array of diff tuples. - * @param {!Array.} lineArray Array of unique strings. - * @private - */ -diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) { - for (var i = 0; i < diffs.length; i++) { - var chars = diffs[i][1]; - var text = []; - for (var j = 0; j < chars.length; j++) { - text[j] = lineArray[chars.charCodeAt(j)]; - } - diffs[i][1] = text.join(''); - } -}; - - -/** - * Determine the common prefix of two strings. - * @param {string} text1 First string. - * @param {string} text2 Second string. - * @return {number} The number of characters common to the start of each - * string. - */ -diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) { - // Quick check for common null cases. - if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) { - return 0; - } - // Binary search. - // Performance analysis: https://neil.fraser.name/news/2007/10/09/ - var pointermin = 0; - var pointermax = Math.min(text1.length, text2.length); - var pointermid = pointermax; - var pointerstart = 0; - while (pointermin < pointermid) { - if (text1.substring(pointerstart, pointermid) == - text2.substring(pointerstart, pointermid)) { - pointermin = pointermid; - pointerstart = pointermin; - } else { - pointermax = pointermid; - } - pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); - } - return pointermid; -}; - - -/** - * Determine the common suffix of two strings. - * @param {string} text1 First string. - * @param {string} text2 Second string. - * @return {number} The number of characters common to the end of each string. - */ -diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) { - // Quick check for common null cases. - if (!text1 || !text2 || - text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) { - return 0; - } - // Binary search. - // Performance analysis: https://neil.fraser.name/news/2007/10/09/ - var pointermin = 0; - var pointermax = Math.min(text1.length, text2.length); - var pointermid = pointermax; - var pointerend = 0; - while (pointermin < pointermid) { - if (text1.substring(text1.length - pointermid, text1.length - pointerend) == - text2.substring(text2.length - pointermid, text2.length - pointerend)) { - pointermin = pointermid; - pointerend = pointermin; - } else { - pointermax = pointermid; - } - pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin); - } - return pointermid; -}; - - -/** - * Determine if the suffix of one string is the prefix of another. - * @param {string} text1 First string. - * @param {string} text2 Second string. - * @return {number} The number of characters common to the end of the first - * string and the start of the second string. - * @private - */ -diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) { - // Cache the text lengths to prevent multiple calls. - var text1_length = text1.length; - var text2_length = text2.length; - // Eliminate the null case. - if (text1_length == 0 || text2_length == 0) { - return 0; - } - // Truncate the longer string. - if (text1_length > text2_length) { - text1 = text1.substring(text1_length - text2_length); - } else if (text1_length < text2_length) { - text2 = text2.substring(0, text1_length); - } - var text_length = Math.min(text1_length, text2_length); - // Quick check for the worst case. - if (text1 == text2) { - return text_length; - } - - // Start by looking for a single character match - // and increase length until no match is found. - // Performance analysis: https://neil.fraser.name/news/2010/11/04/ - var best = 0; - var length = 1; - while (true) { - var pattern = text1.substring(text_length - length); - var found = text2.indexOf(pattern); - if (found == -1) { - return best; - } - length += found; - if (found == 0 || text1.substring(text_length - length) == - text2.substring(0, length)) { - best = length; - length++; - } - } -}; - - -/** - * Do the two texts share a substring which is at least half the length of the - * longer text? - * This speedup can produce non-minimal diffs. - * @param {string} text1 First string. - * @param {string} text2 Second string. - * @return {Array.} Five element Array, containing the prefix of - * text1, the suffix of text1, the prefix of text2, the suffix of - * text2 and the common middle. Or null if there was no match. - * @private - */ -diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) { - if (this.Diff_Timeout <= 0) { - // Don't risk returning a non-optimal diff if we have unlimited time. - return null; - } - var longtext = text1.length > text2.length ? text1 : text2; - var shorttext = text1.length > text2.length ? text2 : text1; - if (longtext.length < 4 || shorttext.length * 2 < longtext.length) { - return null; // Pointless. - } - var dmp = this; // 'this' becomes 'window' in a closure. - - /** - * Does a substring of shorttext exist within longtext such that the substring - * is at least half the length of longtext? - * Closure, but does not reference any external variables. - * @param {string} longtext Longer string. - * @param {string} shorttext Shorter string. - * @param {number} i Start index of quarter length substring within longtext. - * @return {Array.} Five element Array, containing the prefix of - * longtext, the suffix of longtext, the prefix of shorttext, the suffix - * of shorttext and the common middle. Or null if there was no match. - * @private - */ - function diff_halfMatchI_(longtext, shorttext, i) { - // Start with a 1/4 length substring at position i as a seed. - var seed = longtext.substring(i, i + Math.floor(longtext.length / 4)); - var j = -1; - var best_common = ''; - var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b; - while ((j = shorttext.indexOf(seed, j + 1)) != -1) { - var prefixLength = dmp.diff_commonPrefix(longtext.substring(i), - shorttext.substring(j)); - var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i), - shorttext.substring(0, j)); - if (best_common.length < suffixLength + prefixLength) { - best_common = shorttext.substring(j - suffixLength, j) + - shorttext.substring(j, j + prefixLength); - best_longtext_a = longtext.substring(0, i - suffixLength); - best_longtext_b = longtext.substring(i + prefixLength); - best_shorttext_a = shorttext.substring(0, j - suffixLength); - best_shorttext_b = shorttext.substring(j + prefixLength); - } - } - if (best_common.length * 2 >= longtext.length) { - return [best_longtext_a, best_longtext_b, - best_shorttext_a, best_shorttext_b, best_common]; - } else { - return null; - } - } - - // First check if the second quarter is the seed for a half-match. - var hm1 = diff_halfMatchI_(longtext, shorttext, - Math.ceil(longtext.length / 4)); - // Check again based on the third quarter. - var hm2 = diff_halfMatchI_(longtext, shorttext, - Math.ceil(longtext.length / 2)); - var hm; - if (!hm1 && !hm2) { - return null; - } else if (!hm2) { - hm = hm1; - } else if (!hm1) { - hm = hm2; - } else { - // Both matched. Select the longest. - hm = hm1[4].length > hm2[4].length ? hm1 : hm2; - } - - // A half-match was found, sort out the return data. - var text1_a, text1_b, text2_a, text2_b; - if (text1.length > text2.length) { - text1_a = hm[0]; - text1_b = hm[1]; - text2_a = hm[2]; - text2_b = hm[3]; - } else { - text2_a = hm[0]; - text2_b = hm[1]; - text1_a = hm[2]; - text1_b = hm[3]; - } - var mid_common = hm[4]; - return [text1_a, text1_b, text2_a, text2_b, mid_common]; -}; - - -/** - * Reduce the number of edits by eliminating semantically trivial equalities. - * @param {!Array.} diffs Array of diff tuples. - */ -diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) { - var changes = false; - var equalities = []; // Stack of indices where equalities are found. - var equalitiesLength = 0; // Keeping our own length var is faster in JS. - /** @type {?string} */ - var lastEquality = null; - // Always equal to diffs[equalities[equalitiesLength - 1]][1] - var pointer = 0; // Index of current position. - // Number of characters that changed prior to the equality. - var length_insertions1 = 0; - var length_deletions1 = 0; - // Number of characters that changed after the equality. - var length_insertions2 = 0; - var length_deletions2 = 0; - while (pointer < diffs.length) { - if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. - equalities[equalitiesLength++] = pointer; - length_insertions1 = length_insertions2; - length_deletions1 = length_deletions2; - length_insertions2 = 0; - length_deletions2 = 0; - lastEquality = diffs[pointer][1]; - } else { // An insertion or deletion. - if (diffs[pointer][0] == DIFF_INSERT) { - length_insertions2 += diffs[pointer][1].length; - } else { - length_deletions2 += diffs[pointer][1].length; - } - // Eliminate an equality that is smaller or equal to the edits on both - // sides of it. - if (lastEquality && (lastEquality.length <= - Math.max(length_insertions1, length_deletions1)) && - (lastEquality.length <= Math.max(length_insertions2, - length_deletions2))) { - // Duplicate record. - diffs.splice(equalities[equalitiesLength - 1], 0, - new diff_match_patch.Diff(DIFF_DELETE, lastEquality)); - // Change second copy to insert. - diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; - // Throw away the equality we just deleted. - equalitiesLength--; - // Throw away the previous equality (it needs to be reevaluated). - equalitiesLength--; - pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1; - length_insertions1 = 0; // Reset the counters. - length_deletions1 = 0; - length_insertions2 = 0; - length_deletions2 = 0; - lastEquality = null; - changes = true; - } - } - pointer++; - } - - // Normalize the diff. - if (changes) { - this.diff_cleanupMerge(diffs); - } - this.diff_cleanupSemanticLossless(diffs); - - // Find any overlaps between deletions and insertions. - // e.g: abcxxxxxxdef - // -> abcxxxdef - // e.g: xxxabcdefxxx - // -> defxxxabc - // Only extract an overlap if it is as big as the edit ahead or behind it. - pointer = 1; - while (pointer < diffs.length) { - if (diffs[pointer - 1][0] == DIFF_DELETE && - diffs[pointer][0] == DIFF_INSERT) { - var deletion = diffs[pointer - 1][1]; - var insertion = diffs[pointer][1]; - var overlap_length1 = this.diff_commonOverlap_(deletion, insertion); - var overlap_length2 = this.diff_commonOverlap_(insertion, deletion); - if (overlap_length1 >= overlap_length2) { - if (overlap_length1 >= deletion.length / 2 || - overlap_length1 >= insertion.length / 2) { - // Overlap found. Insert an equality and trim the surrounding edits. - diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL, - insertion.substring(0, overlap_length1))); - diffs[pointer - 1][1] = - deletion.substring(0, deletion.length - overlap_length1); - diffs[pointer + 1][1] = insertion.substring(overlap_length1); - pointer++; - } - } else { - if (overlap_length2 >= deletion.length / 2 || - overlap_length2 >= insertion.length / 2) { - // Reverse overlap found. - // Insert an equality and swap and trim the surrounding edits. - diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL, - deletion.substring(0, overlap_length2))); - diffs[pointer - 1][0] = DIFF_INSERT; - diffs[pointer - 1][1] = - insertion.substring(0, insertion.length - overlap_length2); - diffs[pointer + 1][0] = DIFF_DELETE; - diffs[pointer + 1][1] = - deletion.substring(overlap_length2); - pointer++; - } - } - pointer++; - } - pointer++; - } -}; - - -/** - * Look for single edits surrounded on both sides by equalities - * which can be shifted sideways to align the edit to a word boundary. - * e.g: The cat came. -> The cat came. - * @param {!Array.} diffs Array of diff tuples. - */ -diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) { - /** - * Given two strings, compute a score representing whether the internal - * boundary falls on logical boundaries. - * Scores range from 6 (best) to 0 (worst). - * Closure, but does not reference any external variables. - * @param {string} one First string. - * @param {string} two Second string. - * @return {number} The score. - * @private - */ - function diff_cleanupSemanticScore_(one, two) { - if (!one || !two) { - // Edges are the best. - return 6; - } - - // Each port of this function behaves slightly differently due to - // subtle differences in each language's definition of things like - // 'whitespace'. Since this function's purpose is largely cosmetic, - // the choice has been made to use each language's native features - // rather than force total conformity. - var char1 = one.charAt(one.length - 1); - var char2 = two.charAt(0); - var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_); - var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_); - var whitespace1 = nonAlphaNumeric1 && - char1.match(diff_match_patch.whitespaceRegex_); - var whitespace2 = nonAlphaNumeric2 && - char2.match(diff_match_patch.whitespaceRegex_); - var lineBreak1 = whitespace1 && - char1.match(diff_match_patch.linebreakRegex_); - var lineBreak2 = whitespace2 && - char2.match(diff_match_patch.linebreakRegex_); - var blankLine1 = lineBreak1 && - one.match(diff_match_patch.blanklineEndRegex_); - var blankLine2 = lineBreak2 && - two.match(diff_match_patch.blanklineStartRegex_); - - if (blankLine1 || blankLine2) { - // Five points for blank lines. - return 5; - } else if (lineBreak1 || lineBreak2) { - // Four points for line breaks. - return 4; - } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) { - // Three points for end of sentences. - return 3; - } else if (whitespace1 || whitespace2) { - // Two points for whitespace. - return 2; - } else if (nonAlphaNumeric1 || nonAlphaNumeric2) { - // One point for non-alphanumeric. - return 1; - } - return 0; - } - - var pointer = 1; - // Intentionally ignore the first and last element (don't need checking). - while (pointer < diffs.length - 1) { - if (diffs[pointer - 1][0] == DIFF_EQUAL && - diffs[pointer + 1][0] == DIFF_EQUAL) { - // This is a single edit surrounded by equalities. - var equality1 = diffs[pointer - 1][1]; - var edit = diffs[pointer][1]; - var equality2 = diffs[pointer + 1][1]; - - // First, shift the edit as far left as possible. - var commonOffset = this.diff_commonSuffix(equality1, edit); - if (commonOffset) { - var commonString = edit.substring(edit.length - commonOffset); - equality1 = equality1.substring(0, equality1.length - commonOffset); - edit = commonString + edit.substring(0, edit.length - commonOffset); - equality2 = commonString + equality2; - } - - // Second, step character by character right, looking for the best fit. - var bestEquality1 = equality1; - var bestEdit = edit; - var bestEquality2 = equality2; - var bestScore = diff_cleanupSemanticScore_(equality1, edit) + - diff_cleanupSemanticScore_(edit, equality2); - while (edit.charAt(0) === equality2.charAt(0)) { - equality1 += edit.charAt(0); - edit = edit.substring(1) + equality2.charAt(0); - equality2 = equality2.substring(1); - var score = diff_cleanupSemanticScore_(equality1, edit) + - diff_cleanupSemanticScore_(edit, equality2); - // The >= encourages trailing rather than leading whitespace on edits. - if (score >= bestScore) { - bestScore = score; - bestEquality1 = equality1; - bestEdit = edit; - bestEquality2 = equality2; - } - } - - if (diffs[pointer - 1][1] != bestEquality1) { - // We have an improvement, save it back to the diff. - if (bestEquality1) { - diffs[pointer - 1][1] = bestEquality1; - } else { - diffs.splice(pointer - 1, 1); - pointer--; - } - diffs[pointer][1] = bestEdit; - if (bestEquality2) { - diffs[pointer + 1][1] = bestEquality2; - } else { - diffs.splice(pointer + 1, 1); - pointer--; - } - } - } - pointer++; - } -}; - -// Define some regex patterns for matching boundaries. -diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/; -diff_match_patch.whitespaceRegex_ = /\s/; -diff_match_patch.linebreakRegex_ = /[\r\n]/; -diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/; -diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/; - -/** - * Reduce the number of edits by eliminating operationally trivial equalities. - * @param {!Array.} diffs Array of diff tuples. - */ -diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) { - var changes = false; - var equalities = []; // Stack of indices where equalities are found. - var equalitiesLength = 0; // Keeping our own length var is faster in JS. - /** @type {?string} */ - var lastEquality = null; - // Always equal to diffs[equalities[equalitiesLength - 1]][1] - var pointer = 0; // Index of current position. - // Is there an insertion operation before the last equality. - var pre_ins = false; - // Is there a deletion operation before the last equality. - var pre_del = false; - // Is there an insertion operation after the last equality. - var post_ins = false; - // Is there a deletion operation after the last equality. - var post_del = false; - while (pointer < diffs.length) { - if (diffs[pointer][0] == DIFF_EQUAL) { // Equality found. - if (diffs[pointer][1].length < this.Diff_EditCost && - (post_ins || post_del)) { - // Candidate found. - equalities[equalitiesLength++] = pointer; - pre_ins = post_ins; - pre_del = post_del; - lastEquality = diffs[pointer][1]; - } else { - // Not a candidate, and can never become one. - equalitiesLength = 0; - lastEquality = null; - } - post_ins = post_del = false; - } else { // An insertion or deletion. - if (diffs[pointer][0] == DIFF_DELETE) { - post_del = true; - } else { - post_ins = true; - } - /* - * Five types to be split: - * ABXYCD - * AXCD - * ABXC - * AXCD - * ABXC - */ - if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) || - ((lastEquality.length < this.Diff_EditCost / 2) && - (pre_ins + pre_del + post_ins + post_del) == 3))) { - // Duplicate record. - diffs.splice(equalities[equalitiesLength - 1], 0, - new diff_match_patch.Diff(DIFF_DELETE, lastEquality)); - // Change second copy to insert. - diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT; - equalitiesLength--; // Throw away the equality we just deleted; - lastEquality = null; - if (pre_ins && pre_del) { - // No changes made which could affect previous entry, keep going. - post_ins = post_del = true; - equalitiesLength = 0; - } else { - equalitiesLength--; // Throw away the previous equality. - pointer = equalitiesLength > 0 ? - equalities[equalitiesLength - 1] : -1; - post_ins = post_del = false; - } - changes = true; - } - } - pointer++; - } - - if (changes) { - this.diff_cleanupMerge(diffs); - } -}; - - -/** - * Reorder and merge like edit sections. Merge equalities. - * Any edit section can move as long as it doesn't cross an equality. - * @param {!Array.} diffs Array of diff tuples. - */ -diff_match_patch.prototype.diff_cleanupMerge = function(diffs) { - // Add a dummy entry at the end. - diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, '')); - var pointer = 0; - var count_delete = 0; - var count_insert = 0; - var text_delete = ''; - var text_insert = ''; - var commonlength; - while (pointer < diffs.length) { - switch (diffs[pointer][0]) { - case DIFF_INSERT: - count_insert++; - text_insert += diffs[pointer][1]; - pointer++; - break; - case DIFF_DELETE: - count_delete++; - text_delete += diffs[pointer][1]; - pointer++; - break; - case DIFF_EQUAL: - // Upon reaching an equality, check for prior redundancies. - if (count_delete + count_insert > 1) { - if (count_delete !== 0 && count_insert !== 0) { - // Factor out any common prefixies. - commonlength = this.diff_commonPrefix(text_insert, text_delete); - if (commonlength !== 0) { - if ((pointer - count_delete - count_insert) > 0 && - diffs[pointer - count_delete - count_insert - 1][0] == - DIFF_EQUAL) { - diffs[pointer - count_delete - count_insert - 1][1] += - text_insert.substring(0, commonlength); - } else { - diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL, - text_insert.substring(0, commonlength))); - pointer++; - } - text_insert = text_insert.substring(commonlength); - text_delete = text_delete.substring(commonlength); - } - // Factor out any common suffixies. - commonlength = this.diff_commonSuffix(text_insert, text_delete); - if (commonlength !== 0) { - diffs[pointer][1] = text_insert.substring(text_insert.length - - commonlength) + diffs[pointer][1]; - text_insert = text_insert.substring(0, text_insert.length - - commonlength); - text_delete = text_delete.substring(0, text_delete.length - - commonlength); - } - } - // Delete the offending records and add the merged ones. - pointer -= count_delete + count_insert; - diffs.splice(pointer, count_delete + count_insert); - if (text_delete.length) { - diffs.splice(pointer, 0, - new diff_match_patch.Diff(DIFF_DELETE, text_delete)); - pointer++; - } - if (text_insert.length) { - diffs.splice(pointer, 0, - new diff_match_patch.Diff(DIFF_INSERT, text_insert)); - pointer++; - } - pointer++; - } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) { - // Merge this equality with the previous one. - diffs[pointer - 1][1] += diffs[pointer][1]; - diffs.splice(pointer, 1); - } else { - pointer++; - } - count_insert = 0; - count_delete = 0; - text_delete = ''; - text_insert = ''; - break; - } - } - if (diffs[diffs.length - 1][1] === '') { - diffs.pop(); // Remove the dummy entry at the end. - } - - // Second pass: look for single edits surrounded on both sides by equalities - // which can be shifted sideways to eliminate an equality. - // e.g: ABAC -> ABAC - var changes = false; - pointer = 1; - // Intentionally ignore the first and last element (don't need checking). - while (pointer < diffs.length - 1) { - if (diffs[pointer - 1][0] == DIFF_EQUAL && - diffs[pointer + 1][0] == DIFF_EQUAL) { - // This is a single edit surrounded by equalities. - if (diffs[pointer][1].substring(diffs[pointer][1].length - - diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) { - // Shift the edit over the previous equality. - diffs[pointer][1] = diffs[pointer - 1][1] + - diffs[pointer][1].substring(0, diffs[pointer][1].length - - diffs[pointer - 1][1].length); - diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1]; - diffs.splice(pointer - 1, 1); - changes = true; - } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) == - diffs[pointer + 1][1]) { - // Shift the edit over the next equality. - diffs[pointer - 1][1] += diffs[pointer + 1][1]; - diffs[pointer][1] = - diffs[pointer][1].substring(diffs[pointer + 1][1].length) + - diffs[pointer + 1][1]; - diffs.splice(pointer + 1, 1); - changes = true; - } - } - pointer++; - } - // If shifts were made, the diff needs reordering and another shift sweep. - if (changes) { - this.diff_cleanupMerge(diffs); - } -}; - - -/** - * loc is a location in text1, compute and return the equivalent location in - * text2. - * e.g. 'The cat' vs 'The big cat', 1->1, 5->8 - * @param {!Array.} diffs Array of diff tuples. - * @param {number} loc Location within text1. - * @return {number} Location within text2. - */ -diff_match_patch.prototype.diff_xIndex = function(diffs, loc) { - var chars1 = 0; - var chars2 = 0; - var last_chars1 = 0; - var last_chars2 = 0; - var x; - for (x = 0; x < diffs.length; x++) { - if (diffs[x][0] !== DIFF_INSERT) { // Equality or deletion. - chars1 += diffs[x][1].length; - } - if (diffs[x][0] !== DIFF_DELETE) { // Equality or insertion. - chars2 += diffs[x][1].length; - } - if (chars1 > loc) { // Overshot the location. - break; - } - last_chars1 = chars1; - last_chars2 = chars2; - } - // Was the location was deleted? - if (diffs.length != x && diffs[x][0] === DIFF_DELETE) { - return last_chars2; - } - // Add the remaining character length. - return last_chars2 + (loc - last_chars1); -}; - - -/** - * Convert a diff array into a pretty HTML report. - * @param {!Array.} diffs Array of diff tuples. - * @return {string} HTML representation. - */ -diff_match_patch.prototype.diff_prettyHtml = function(diffs) { - var html = []; - var pattern_amp = /&/g; - var pattern_lt = //g; - var pattern_para = /\n/g; - for (var x = 0; x < diffs.length; x++) { - var op = diffs[x][0]; // Operation (insert, delete, equal) - var data = diffs[x][1]; // Text of change. - var text = data.replace(pattern_amp, '&').replace(pattern_lt, '<') - .replace(pattern_gt, '>').replace(pattern_para, '¶
'); - switch (op) { - case DIFF_INSERT: - html[x] = '' + text + ''; - break; - case DIFF_DELETE: - html[x] = '' + text + ''; - break; - case DIFF_EQUAL: - html[x] = '' + text + ''; - break; - } - } - return html.join(''); -}; - - -/** - * Compute and return the source text (all equalities and deletions). - * @param {!Array.} diffs Array of diff tuples. - * @return {string} Source text. - */ -diff_match_patch.prototype.diff_text1 = function(diffs) { - var text = []; - for (var x = 0; x < diffs.length; x++) { - if (diffs[x][0] !== DIFF_INSERT) { - text[x] = diffs[x][1]; - } - } - return text.join(''); -}; - - -/** - * Compute and return the destination text (all equalities and insertions). - * @param {!Array.} diffs Array of diff tuples. - * @return {string} Destination text. - */ -diff_match_patch.prototype.diff_text2 = function(diffs) { - var text = []; - for (var x = 0; x < diffs.length; x++) { - if (diffs[x][0] !== DIFF_DELETE) { - text[x] = diffs[x][1]; - } - } - return text.join(''); -}; - - -/** - * Compute the Levenshtein distance; the number of inserted, deleted or - * substituted characters. - * @param {!Array.} diffs Array of diff tuples. - * @return {number} Number of changes. - */ -diff_match_patch.prototype.diff_levenshtein = function(diffs) { - var levenshtein = 0; - var insertions = 0; - var deletions = 0; - for (var x = 0; x < diffs.length; x++) { - var op = diffs[x][0]; - var data = diffs[x][1]; - switch (op) { - case DIFF_INSERT: - insertions += data.length; - break; - case DIFF_DELETE: - deletions += data.length; - break; - case DIFF_EQUAL: - // A deletion and an insertion is one substitution. - levenshtein += Math.max(insertions, deletions); - insertions = 0; - deletions = 0; - break; - } - } - levenshtein += Math.max(insertions, deletions); - return levenshtein; -}; - - -/** - * Crush the diff into an encoded string which describes the operations - * required to transform text1 into text2. - * E.g. =3\t-2\t+ing -> Keep 3 chars, delete 2 chars, insert 'ing'. - * Operations are tab-separated. Inserted text is escaped using %xx notation. - * @param {!Array.} diffs Array of diff tuples. - * @return {string} Delta text. - */ -diff_match_patch.prototype.diff_toDelta = function(diffs) { - var text = []; - for (var x = 0; x < diffs.length; x++) { - switch (diffs[x][0]) { - case DIFF_INSERT: - text[x] = '+' + encodeURI(diffs[x][1]); - break; - case DIFF_DELETE: - text[x] = '-' + diffs[x][1].length; - break; - case DIFF_EQUAL: - text[x] = '=' + diffs[x][1].length; - break; - } - } - return text.join('\t').replace(/%20/g, ' '); -}; - - -/** - * Given the original text1, and an encoded string which describes the - * operations required to transform text1 into text2, compute the full diff. - * @param {string} text1 Source string for the diff. - * @param {string} delta Delta text. - * @return {!Array.} Array of diff tuples. - * @throws {!Error} If invalid input. - */ -diff_match_patch.prototype.diff_fromDelta = function(text1, delta) { - var diffs = []; - var diffsLength = 0; // Keeping our own length var is faster in JS. - var pointer = 0; // Cursor in text1 - var tokens = delta.split(/\t/g); - for (var x = 0; x < tokens.length; x++) { - // Each token begins with a one character parameter which specifies the - // operation of this token (delete, insert, equality). - var param = tokens[x].substring(1); - switch (tokens[x].charAt(0)) { - case '+': - try { - diffs[diffsLength++] = - new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param)); - } catch (ex) { - // Malformed URI sequence. - throw new Error('Illegal escape in diff_fromDelta: ' + param); - } - break; - case '-': - // Fall through. - case '=': - var n = parseInt(param, 10); - if (isNaN(n) || n < 0) { - throw new Error('Invalid number in diff_fromDelta: ' + param); - } - var text = text1.substring(pointer, pointer += n); - if (tokens[x].charAt(0) == '=') { - diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text); - } else { - diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text); - } - break; - default: - // Blank tokens are ok (from a trailing \t). - // Anything else is an error. - if (tokens[x]) { - throw new Error('Invalid diff operation in diff_fromDelta: ' + - tokens[x]); - } - } - } - if (pointer != text1.length) { - throw new Error('Delta length (' + pointer + - ') does not equal source text length (' + text1.length + ').'); - } - return diffs; -}; - - -// MATCH FUNCTIONS - - -/** - * Locate the best instance of 'pattern' in 'text' near 'loc'. - * @param {string} text The text to search. - * @param {string} pattern The pattern to search for. - * @param {number} loc The location to search around. - * @return {number} Best match index or -1. - */ -diff_match_patch.prototype.match_main = function(text, pattern, loc) { - // Check for null inputs. - if (text == null || pattern == null || loc == null) { - throw new Error('Null input. (match_main)'); - } - - loc = Math.max(0, Math.min(loc, text.length)); - if (text == pattern) { - // Shortcut (potentially not guaranteed by the algorithm) - return 0; - } else if (!text.length) { - // Nothing to match. - return -1; - } else if (text.substring(loc, loc + pattern.length) == pattern) { - // Perfect match at the perfect spot! (Includes case of null pattern) - return loc; - } else { - // Do a fuzzy compare. - return this.match_bitap_(text, pattern, loc); - } -}; - - -/** - * Locate the best instance of 'pattern' in 'text' near 'loc' using the - * Bitap algorithm. - * @param {string} text The text to search. - * @param {string} pattern The pattern to search for. - * @param {number} loc The location to search around. - * @return {number} Best match index or -1. - * @private - */ -diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) { - if (pattern.length > this.Match_MaxBits) { - throw new Error('Pattern too long for this browser.'); - } - - // Initialise the alphabet. - var s = this.match_alphabet_(pattern); - - var dmp = this; // 'this' becomes 'window' in a closure. - - /** - * Compute and return the score for a match with e errors and x location. - * Accesses loc and pattern through being a closure. - * @param {number} e Number of errors in match. - * @param {number} x Location of match. - * @return {number} Overall score for match (0.0 = good, 1.0 = bad). - * @private - */ - function match_bitapScore_(e, x) { - var accuracy = e / pattern.length; - var proximity = Math.abs(loc - x); - if (!dmp.Match_Distance) { - // Dodge divide by zero error. - return proximity ? 1.0 : accuracy; - } - return accuracy + (proximity / dmp.Match_Distance); - } - - // Highest score beyond which we give up. - var score_threshold = this.Match_Threshold; - // Is there a nearby exact match? (speedup) - var best_loc = text.indexOf(pattern, loc); - if (best_loc != -1) { - score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold); - // What about in the other direction? (speedup) - best_loc = text.lastIndexOf(pattern, loc + pattern.length); - if (best_loc != -1) { - score_threshold = - Math.min(match_bitapScore_(0, best_loc), score_threshold); - } - } - - // Initialise the bit arrays. - var matchmask = 1 << (pattern.length - 1); - best_loc = -1; - - var bin_min, bin_mid; - var bin_max = pattern.length + text.length; - var last_rd; - for (var d = 0; d < pattern.length; d++) { - // Scan for the best match; each iteration allows for one more error. - // Run a binary search to determine how far from 'loc' we can stray at this - // error level. - bin_min = 0; - bin_mid = bin_max; - while (bin_min < bin_mid) { - if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) { - bin_min = bin_mid; - } else { - bin_max = bin_mid; - } - bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min); - } - // Use the result from this iteration as the maximum for the next. - bin_max = bin_mid; - var start = Math.max(1, loc - bin_mid + 1); - var finish = Math.min(loc + bin_mid, text.length) + pattern.length; - - var rd = Array(finish + 2); - rd[finish + 1] = (1 << d) - 1; - for (var j = finish; j >= start; j--) { - // The alphabet (s) is a sparse hash, so the following line generates - // warnings. - var charMatch = s[text.charAt(j - 1)]; - if (d === 0) { // First pass: exact match. - rd[j] = ((rd[j + 1] << 1) | 1) & charMatch; - } else { // Subsequent passes: fuzzy match. - rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) | - (((last_rd[j + 1] | last_rd[j]) << 1) | 1) | - last_rd[j + 1]; - } - if (rd[j] & matchmask) { - var score = match_bitapScore_(d, j - 1); - // This match will almost certainly be better than any existing match. - // But check anyway. - if (score <= score_threshold) { - // Told you so. - score_threshold = score; - best_loc = j - 1; - if (best_loc > loc) { - // When passing loc, don't exceed our current distance from loc. - start = Math.max(1, 2 * loc - best_loc); - } else { - // Already passed loc, downhill from here on in. - break; - } - } - } - } - // No hope for a (better) match at greater error levels. - if (match_bitapScore_(d + 1, loc) > score_threshold) { - break; - } - last_rd = rd; - } - return best_loc; -}; - - -/** - * Initialise the alphabet for the Bitap algorithm. - * @param {string} pattern The text to encode. - * @return {!Object} Hash of character locations. - * @private - */ -diff_match_patch.prototype.match_alphabet_ = function(pattern) { - var s = {}; - for (var i = 0; i < pattern.length; i++) { - s[pattern.charAt(i)] = 0; - } - for (var i = 0; i < pattern.length; i++) { - s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1); - } - return s; -}; - - -// PATCH FUNCTIONS - - -/** - * Increase the context until it is unique, - * but don't let the pattern expand beyond Match_MaxBits. - * @param {!diff_match_patch.patch_obj} patch The patch to grow. - * @param {string} text Source text. - * @private - */ -diff_match_patch.prototype.patch_addContext_ = function(patch, text) { - if (text.length == 0) { - return; - } - if (patch.start2 === null) { - throw Error('patch not initialized'); - } - var pattern = text.substring(patch.start2, patch.start2 + patch.length1); - var padding = 0; - - // Look for the first and last matches of pattern in text. If two different - // matches are found, increase the pattern length. - while (text.indexOf(pattern) != text.lastIndexOf(pattern) && - pattern.length < this.Match_MaxBits - this.Patch_Margin - - this.Patch_Margin) { - padding += this.Patch_Margin; - pattern = text.substring(patch.start2 - padding, - patch.start2 + patch.length1 + padding); - } - // Add one chunk for good luck. - padding += this.Patch_Margin; - - // Add the prefix. - var prefix = text.substring(patch.start2 - padding, patch.start2); - if (prefix) { - patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix)); - } - // Add the suffix. - var suffix = text.substring(patch.start2 + patch.length1, - patch.start2 + patch.length1 + padding); - if (suffix) { - patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix)); - } - - // Roll back the start points. - patch.start1 -= prefix.length; - patch.start2 -= prefix.length; - // Extend the lengths. - patch.length1 += prefix.length + suffix.length; - patch.length2 += prefix.length + suffix.length; -}; - - -/** - * Compute a list of patches to turn text1 into text2. - * Use diffs if provided, otherwise compute it ourselves. - * There are four ways to call this function, depending on what data is - * available to the caller: - * Method 1: - * a = text1, b = text2 - * Method 2: - * a = diffs - * Method 3 (optimal): - * a = text1, b = diffs - * Method 4 (deprecated, use method 3): - * a = text1, b = text2, c = diffs - * - * @param {string|!Array.} a text1 (methods 1,3,4) or - * Array of diff tuples for text1 to text2 (method 2). - * @param {string|!Array.=} opt_b text2 (methods 1,4) or - * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2). - * @param {string|!Array.=} opt_c Array of diff tuples - * for text1 to text2 (method 4) or undefined (methods 1,2,3). - * @return {!Array.} Array of Patch objects. - */ -diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) { - var text1, diffs; - if (typeof a == 'string' && typeof opt_b == 'string' && - typeof opt_c == 'undefined') { - // Method 1: text1, text2 - // Compute diffs from text1 and text2. - text1 = /** @type {string} */(a); - diffs = this.diff_main(text1, /** @type {string} */(opt_b), true); - if (diffs.length > 2) { - this.diff_cleanupSemantic(diffs); - this.diff_cleanupEfficiency(diffs); - } - } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' && - typeof opt_c == 'undefined') { - // Method 2: diffs - // Compute text1 from diffs. - diffs = /** @type {!Array.} */(a); - text1 = this.diff_text1(diffs); - } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' && - typeof opt_c == 'undefined') { - // Method 3: text1, diffs - text1 = /** @type {string} */(a); - diffs = /** @type {!Array.} */(opt_b); - } else if (typeof a == 'string' && typeof opt_b == 'string' && - opt_c && typeof opt_c == 'object') { - // Method 4: text1, text2, diffs - // text2 is not used. - text1 = /** @type {string} */(a); - diffs = /** @type {!Array.} */(opt_c); - } else { - throw new Error('Unknown call format to patch_make.'); - } - - if (diffs.length === 0) { - return []; // Get rid of the null case. - } - var patches = []; - var patch = new diff_match_patch.patch_obj(); - var patchDiffLength = 0; // Keeping our own length var is faster in JS. - var char_count1 = 0; // Number of characters into the text1 string. - var char_count2 = 0; // Number of characters into the text2 string. - // Start with text1 (prepatch_text) and apply the diffs until we arrive at - // text2 (postpatch_text). We recreate the patches one by one to determine - // context info. - var prepatch_text = text1; - var postpatch_text = text1; - for (var x = 0; x < diffs.length; x++) { - var diff_type = diffs[x][0]; - var diff_text = diffs[x][1]; - - if (!patchDiffLength && diff_type !== DIFF_EQUAL) { - // A new patch starts here. - patch.start1 = char_count1; - patch.start2 = char_count2; - } - - switch (diff_type) { - case DIFF_INSERT: - patch.diffs[patchDiffLength++] = diffs[x]; - patch.length2 += diff_text.length; - postpatch_text = postpatch_text.substring(0, char_count2) + diff_text + - postpatch_text.substring(char_count2); - break; - case DIFF_DELETE: - patch.length1 += diff_text.length; - patch.diffs[patchDiffLength++] = diffs[x]; - postpatch_text = postpatch_text.substring(0, char_count2) + - postpatch_text.substring(char_count2 + - diff_text.length); - break; - case DIFF_EQUAL: - if (diff_text.length <= 2 * this.Patch_Margin && - patchDiffLength && diffs.length != x + 1) { - // Small equality inside a patch. - patch.diffs[patchDiffLength++] = diffs[x]; - patch.length1 += diff_text.length; - patch.length2 += diff_text.length; - } else if (diff_text.length >= 2 * this.Patch_Margin) { - // Time for a new patch. - if (patchDiffLength) { - this.patch_addContext_(patch, prepatch_text); - patches.push(patch); - patch = new diff_match_patch.patch_obj(); - patchDiffLength = 0; - // Unlike Unidiff, our patch lists have a rolling context. - // https://github.com/google/diff-match-patch/wiki/Unidiff - // Update prepatch text & pos to reflect the application of the - // just completed patch. - prepatch_text = postpatch_text; - char_count1 = char_count2; - } - } - break; - } - - // Update the current character count. - if (diff_type !== DIFF_INSERT) { - char_count1 += diff_text.length; - } - if (diff_type !== DIFF_DELETE) { - char_count2 += diff_text.length; - } - } - // Pick up the leftover patch if not empty. - if (patchDiffLength) { - this.patch_addContext_(patch, prepatch_text); - patches.push(patch); - } - - return patches; -}; - - -/** - * Given an array of patches, return another array that is identical. - * @param {!Array.} patches Array of Patch objects. - * @return {!Array.} Array of Patch objects. - */ -diff_match_patch.prototype.patch_deepCopy = function(patches) { - // Making deep copies is hard in JavaScript. - var patchesCopy = []; - for (var x = 0; x < patches.length; x++) { - var patch = patches[x]; - var patchCopy = new diff_match_patch.patch_obj(); - patchCopy.diffs = []; - for (var y = 0; y < patch.diffs.length; y++) { - patchCopy.diffs[y] = - new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]); - } - patchCopy.start1 = patch.start1; - patchCopy.start2 = patch.start2; - patchCopy.length1 = patch.length1; - patchCopy.length2 = patch.length2; - patchesCopy[x] = patchCopy; - } - return patchesCopy; -}; - - -/** - * Merge a set of patches onto the text. Return a patched text, as well - * as a list of true/false values indicating which patches were applied. - * @param {!Array.} patches Array of Patch objects. - * @param {string} text Old text. - * @return {!Array.>} Two element Array, containing the - * new text and an array of boolean values. - */ -diff_match_patch.prototype.patch_apply = function(patches, text) { - if (patches.length == 0) { - return [text, []]; - } - - // Deep copy the patches so that no changes are made to originals. - patches = this.patch_deepCopy(patches); - - var nullPadding = this.patch_addPadding(patches); - text = nullPadding + text + nullPadding; - - this.patch_splitMax(patches); - // delta keeps track of the offset between the expected and actual location - // of the previous patch. If there are patches expected at positions 10 and - // 20, but the first patch was found at 12, delta is 2 and the second patch - // has an effective expected position of 22. - var delta = 0; - var results = []; - for (var x = 0; x < patches.length; x++) { - var expected_loc = patches[x].start2 + delta; - var text1 = this.diff_text1(patches[x].diffs); - var start_loc; - var end_loc = -1; - if (text1.length > this.Match_MaxBits) { - // patch_splitMax will only provide an oversized pattern in the case of - // a monster delete. - start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits), - expected_loc); - if (start_loc != -1) { - end_loc = this.match_main(text, - text1.substring(text1.length - this.Match_MaxBits), - expected_loc + text1.length - this.Match_MaxBits); - if (end_loc == -1 || start_loc >= end_loc) { - // Can't find valid trailing context. Drop this patch. - start_loc = -1; - } - } - } else { - start_loc = this.match_main(text, text1, expected_loc); - } - if (start_loc == -1) { - // No match found. :( - results[x] = false; - // Subtract the delta for this failed patch from subsequent patches. - delta -= patches[x].length2 - patches[x].length1; - } else { - // Found a match. :) - results[x] = true; - delta = start_loc - expected_loc; - var text2; - if (end_loc == -1) { - text2 = text.substring(start_loc, start_loc + text1.length); - } else { - text2 = text.substring(start_loc, end_loc + this.Match_MaxBits); - } - if (text1 == text2) { - // Perfect match, just shove the replacement text in. - text = text.substring(0, start_loc) + - this.diff_text2(patches[x].diffs) + - text.substring(start_loc + text1.length); - } else { - // Imperfect match. Run a diff to get a framework of equivalent - // indices. - var diffs = this.diff_main(text1, text2, false); - if (text1.length > this.Match_MaxBits && - this.diff_levenshtein(diffs) / text1.length > - this.Patch_DeleteThreshold) { - // The end points match, but the content is unacceptably bad. - results[x] = false; - } else { - this.diff_cleanupSemanticLossless(diffs); - var index1 = 0; - var index2; - for (var y = 0; y < patches[x].diffs.length; y++) { - var mod = patches[x].diffs[y]; - if (mod[0] !== DIFF_EQUAL) { - index2 = this.diff_xIndex(diffs, index1); - } - if (mod[0] === DIFF_INSERT) { // Insertion - text = text.substring(0, start_loc + index2) + mod[1] + - text.substring(start_loc + index2); - } else if (mod[0] === DIFF_DELETE) { // Deletion - text = text.substring(0, start_loc + index2) + - text.substring(start_loc + this.diff_xIndex(diffs, - index1 + mod[1].length)); - } - if (mod[0] !== DIFF_DELETE) { - index1 += mod[1].length; - } - } - } - } - } - } - // Strip the padding off. - text = text.substring(nullPadding.length, text.length - nullPadding.length); - return [text, results]; -}; - - -/** - * Add some padding on text start and end so that edges can match something. - * Intended to be called only from within patch_apply. - * @param {!Array.} patches Array of Patch objects. - * @return {string} The padding string added to each side. - */ -diff_match_patch.prototype.patch_addPadding = function(patches) { - var paddingLength = this.Patch_Margin; - var nullPadding = ''; - for (var x = 1; x <= paddingLength; x++) { - nullPadding += String.fromCharCode(x); - } - - // Bump all the patches forward. - for (var x = 0; x < patches.length; x++) { - patches[x].start1 += paddingLength; - patches[x].start2 += paddingLength; - } - - // Add some padding on start of first diff. - var patch = patches[0]; - var diffs = patch.diffs; - if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) { - // Add nullPadding equality. - diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding)); - patch.start1 -= paddingLength; // Should be 0. - patch.start2 -= paddingLength; // Should be 0. - patch.length1 += paddingLength; - patch.length2 += paddingLength; - } else if (paddingLength > diffs[0][1].length) { - // Grow first equality. - var extraLength = paddingLength - diffs[0][1].length; - diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1]; - patch.start1 -= extraLength; - patch.start2 -= extraLength; - patch.length1 += extraLength; - patch.length2 += extraLength; - } - - // Add some padding on end of last diff. - patch = patches[patches.length - 1]; - diffs = patch.diffs; - if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) { - // Add nullPadding equality. - diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding)); - patch.length1 += paddingLength; - patch.length2 += paddingLength; - } else if (paddingLength > diffs[diffs.length - 1][1].length) { - // Grow last equality. - var extraLength = paddingLength - diffs[diffs.length - 1][1].length; - diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength); - patch.length1 += extraLength; - patch.length2 += extraLength; - } - - return nullPadding; -}; - - -/** - * Look through the patches and break up any which are longer than the maximum - * limit of the match algorithm. - * Intended to be called only from within patch_apply. - * @param {!Array.} patches Array of Patch objects. - */ -diff_match_patch.prototype.patch_splitMax = function(patches) { - var patch_size = this.Match_MaxBits; - for (var x = 0; x < patches.length; x++) { - if (patches[x].length1 <= patch_size) { - continue; - } - var bigpatch = patches[x]; - // Remove the big old patch. - patches.splice(x--, 1); - var start1 = bigpatch.start1; - var start2 = bigpatch.start2; - var precontext = ''; - while (bigpatch.diffs.length !== 0) { - // Create one of several smaller patches. - var patch = new diff_match_patch.patch_obj(); - var empty = true; - patch.start1 = start1 - precontext.length; - patch.start2 = start2 - precontext.length; - if (precontext !== '') { - patch.length1 = patch.length2 = precontext.length; - patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext)); - } - while (bigpatch.diffs.length !== 0 && - patch.length1 < patch_size - this.Patch_Margin) { - var diff_type = bigpatch.diffs[0][0]; - var diff_text = bigpatch.diffs[0][1]; - if (diff_type === DIFF_INSERT) { - // Insertions are harmless. - patch.length2 += diff_text.length; - start2 += diff_text.length; - patch.diffs.push(bigpatch.diffs.shift()); - empty = false; - } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 && - patch.diffs[0][0] == DIFF_EQUAL && - diff_text.length > 2 * patch_size) { - // This is a large deletion. Let it pass in one chunk. - patch.length1 += diff_text.length; - start1 += diff_text.length; - empty = false; - patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)); - bigpatch.diffs.shift(); - } else { - // Deletion or equality. Only take as much as we can stomach. - diff_text = diff_text.substring(0, - patch_size - patch.length1 - this.Patch_Margin); - patch.length1 += diff_text.length; - start1 += diff_text.length; - if (diff_type === DIFF_EQUAL) { - patch.length2 += diff_text.length; - start2 += diff_text.length; - } else { - empty = false; - } - patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text)); - if (diff_text == bigpatch.diffs[0][1]) { - bigpatch.diffs.shift(); - } else { - bigpatch.diffs[0][1] = - bigpatch.diffs[0][1].substring(diff_text.length); - } - } - } - // Compute the head context for the next patch. - precontext = this.diff_text2(patch.diffs); - precontext = - precontext.substring(precontext.length - this.Patch_Margin); - // Append the end context for this patch. - var postcontext = this.diff_text1(bigpatch.diffs) - .substring(0, this.Patch_Margin); - if (postcontext !== '') { - patch.length1 += postcontext.length; - patch.length2 += postcontext.length; - if (patch.diffs.length !== 0 && - patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) { - patch.diffs[patch.diffs.length - 1][1] += postcontext; - } else { - patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext)); - } - } - if (!empty) { - patches.splice(++x, 0, patch); - } - } - } -}; - - -/** - * Take a list of patches and return a textual representation. - * @param {!Array.} patches Array of Patch objects. - * @return {string} Text representation of patches. - */ -diff_match_patch.prototype.patch_toText = function(patches) { - var text = []; - for (var x = 0; x < patches.length; x++) { - text[x] = patches[x]; - } - return text.join(''); -}; - - -/** - * Parse a textual representation of patches and return a list of Patch objects. - * @param {string} textline Text representation of patches. - * @return {!Array.} Array of Patch objects. - * @throws {!Error} If invalid input. - */ -diff_match_patch.prototype.patch_fromText = function(textline) { - var patches = []; - if (!textline) { - return patches; - } - var text = textline.split('\n'); - var textPointer = 0; - var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/; - while (textPointer < text.length) { - var m = text[textPointer].match(patchHeader); - if (!m) { - throw new Error('Invalid patch string: ' + text[textPointer]); - } - var patch = new diff_match_patch.patch_obj(); - patches.push(patch); - patch.start1 = parseInt(m[1], 10); - if (m[2] === '') { - patch.start1--; - patch.length1 = 1; - } else if (m[2] == '0') { - patch.length1 = 0; - } else { - patch.start1--; - patch.length1 = parseInt(m[2], 10); - } - - patch.start2 = parseInt(m[3], 10); - if (m[4] === '') { - patch.start2--; - patch.length2 = 1; - } else if (m[4] == '0') { - patch.length2 = 0; - } else { - patch.start2--; - patch.length2 = parseInt(m[4], 10); - } - textPointer++; - - while (textPointer < text.length) { - var sign = text[textPointer].charAt(0); - try { - var line = decodeURI(text[textPointer].substring(1)); - } catch (ex) { - // Malformed URI sequence. - throw new Error('Illegal escape in patch_fromText: ' + line); - } - if (sign == '-') { - // Deletion. - patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line)); - } else if (sign == '+') { - // Insertion. - patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line)); - } else if (sign == ' ') { - // Minor equality. - patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line)); - } else if (sign == '@') { - // Start of next patch. - break; - } else if (sign === '') { - // Blank line? Whatever. - } else { - // WTF? - throw new Error('Invalid patch mode "' + sign + '" in: ' + line); - } - textPointer++; - } - } - return patches; -}; - - -/** - * Class representing one patch operation. - * @constructor - */ -diff_match_patch.patch_obj = function() { - /** @type {!Array.} */ - this.diffs = []; - /** @type {?number} */ - this.start1 = null; - /** @type {?number} */ - this.start2 = null; - /** @type {number} */ - this.length1 = 0; - /** @type {number} */ - this.length2 = 0; -}; - - -/** - * Emulate GNU diff's format. - * Header: @@ -382,8 +481,9 @@ - * Indices are printed as 1-based, not 0-based. - * @return {string} The GNU diff string. - */ -diff_match_patch.patch_obj.prototype.toString = function() { - var coords1, coords2; - if (this.length1 === 0) { - coords1 = this.start1 + ',0'; - } else if (this.length1 == 1) { - coords1 = this.start1 + 1; - } else { - coords1 = (this.start1 + 1) + ',' + this.length1; - } - if (this.length2 === 0) { - coords2 = this.start2 + ',0'; - } else if (this.length2 == 1) { - coords2 = this.start2 + 1; - } else { - coords2 = (this.start2 + 1) + ',' + this.length2; - } - var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n']; - var op; - // Escape the body of the patch with %xx notation. - for (var x = 0; x < this.diffs.length; x++) { - switch (this.diffs[x][0]) { - case DIFF_INSERT: - op = '+'; - break; - case DIFF_DELETE: - op = '-'; - break; - case DIFF_EQUAL: - op = ' '; - break; - } - text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n'; - } - return text.join('').replace(/%20/g, ' '); -}; - - -// The following export code was added by @ForbesLindesay -module.exports = diff_match_patch; -module.exports.diff_match_patch = diff_match_patch; -module.exports.DIFF_DELETE = DIFF_DELETE; -module.exports.DIFF_INSERT = DIFF_INSERT; -module.exports.DIFF_EQUAL = DIFF_EQUAL; - -/***/ }), - -/***/ 9208: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -/** - * lodash (Custom Build) - * Build: `lodash modularize exports="npm" -o ./` - * Copyright jQuery Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ - -/** Used as the `TypeError` message for "Functions" methods. */ -var FUNC_ERROR_TEXT = 'Expected a function'; - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** Used as references for various `Number` constants. */ -var INFINITY = 1 / 0; - -/** `Object#toString` result references. */ -var funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - symbolTag = '[object Symbol]'; - -/** Used to match property names within property paths. */ -var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, - reIsPlainProp = /^\w*$/, - reLeadingDot = /^\./, - rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; - -/** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ -var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; - -/** Used to match backslashes in property paths. */ -var reEscapeChar = /\\(\\)?/g; - -/** Used to detect host constructors (Safari). */ -var reIsHostCtor = /^\[object .+?Constructor\]$/; - -/** Detect free variable `global` from Node.js. */ -var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g; - -/** Detect free variable `self`. */ -var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - -/** Used as a reference to the global object. */ -var root = freeGlobal || freeSelf || Function('return this')(); - -/** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ -function getValue(object, key) { - return object == null ? undefined : object[key]; -} - -/** - * Checks if `value` is a host object in IE < 9. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a host object, else `false`. - */ -function isHostObject(value) { - // Many host objects are `Object` objects that can coerce to strings - // despite having improperly defined `toString` methods. - var result = false; - if (value != null && typeof value.toString != 'function') { - try { - result = !!(value + ''); - } catch (e) {} - } - return result; -} - -/** Used for built-in method references. */ -var arrayProto = Array.prototype, - funcProto = Function.prototype, - objectProto = Object.prototype; - -/** Used to detect overreaching core-js shims. */ -var coreJsData = root['__core-js_shared__']; - -/** Used to detect methods masquerading as native. */ -var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; -}()); - -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var objectToString = objectProto.toString; - -/** Used to detect if a method is native. */ -var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' -); - -/** Built-in value references. */ -var Symbol = root.Symbol, - splice = arrayProto.splice; - -/* Built-in method references that are verified to be native. */ -var Map = getNative(root, 'Map'), - nativeCreate = getNative(Object, 'create'); - -/** Used to convert symbols to primitives and strings. */ -var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolToString = symbolProto ? symbolProto.toString : undefined; - -/** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Hash(entries) { - var index = -1, - length = entries ? entries.length : 0; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ -function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; -} - -/** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function hashDelete(key) { - return this.has(key) && delete this.__data__[key]; -} - -/** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; -} - -/** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function hashHas(key) { - var data = this.__data__; - return nativeCreate ? data[key] !== undefined : hasOwnProperty.call(data, key); -} - -/** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ -function hashSet(key, value) { - var data = this.__data__; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; - return this; -} - -// Add methods to `Hash`. -Hash.prototype.clear = hashClear; -Hash.prototype['delete'] = hashDelete; -Hash.prototype.get = hashGet; -Hash.prototype.has = hashHas; -Hash.prototype.set = hashSet; - -/** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function ListCache(entries) { - var index = -1, - length = entries ? entries.length : 0; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ -function listCacheClear() { - this.__data__ = []; -} - -/** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); - } - return true; -} - -/** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; -} - -/** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; -} - -/** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ -function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; -} - -// Add methods to `ListCache`. -ListCache.prototype.clear = listCacheClear; -ListCache.prototype['delete'] = listCacheDelete; -ListCache.prototype.get = listCacheGet; -ListCache.prototype.has = listCacheHas; -ListCache.prototype.set = listCacheSet; - -/** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function MapCache(entries) { - var index = -1, - length = entries ? entries.length : 0; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ -function mapCacheClear() { - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; -} - -/** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function mapCacheDelete(key) { - return getMapData(this, key)['delete'](key); -} - -/** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function mapCacheGet(key) { - return getMapData(this, key).get(key); -} - -/** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function mapCacheHas(key) { - return getMapData(this, key).has(key); -} - -/** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ -function mapCacheSet(key, value) { - getMapData(this, key).set(key, value); - return this; -} - -// Add methods to `MapCache`. -MapCache.prototype.clear = mapCacheClear; -MapCache.prototype['delete'] = mapCacheDelete; -MapCache.prototype.get = mapCacheGet; -MapCache.prototype.has = mapCacheHas; -MapCache.prototype.set = mapCacheSet; - -/** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ -function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; - } - } - return -1; -} - -/** - * The base implementation of `_.get` without support for default values. - * - * @private - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @returns {*} Returns the resolved value. - */ -function baseGet(object, path) { - path = isKey(path, object) ? [path] : castPath(path); - - var index = 0, - length = path.length; - - while (object != null && index < length) { - object = object[toKey(path[index++])]; - } - return (index && index == length) ? object : undefined; -} - -/** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ -function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = (isFunction(value) || isHostObject(value)) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); -} - -/** - * The base implementation of `_.toString` which doesn't convert nullish - * values to empty strings. - * - * @private - * @param {*} value The value to process. - * @returns {string} Returns the string. - */ -function baseToString(value) { - // Exit early for strings to avoid a performance hit in some environments. - if (typeof value == 'string') { - return value; - } - if (isSymbol(value)) { - return symbolToString ? symbolToString.call(value) : ''; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; -} - -/** - * Casts `value` to a path array if it's not one. - * - * @private - * @param {*} value The value to inspect. - * @returns {Array} Returns the cast property path array. - */ -function castPath(value) { - return isArray(value) ? value : stringToPath(value); -} - -/** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ -function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; -} - -/** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ -function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; -} - -/** - * Checks if `value` is a property name and not a property path. - * - * @private - * @param {*} value The value to check. - * @param {Object} [object] The object to query keys on. - * @returns {boolean} Returns `true` if `value` is a property name, else `false`. - */ -function isKey(value, object) { - if (isArray(value)) { - return false; - } - var type = typeof value; - if (type == 'number' || type == 'symbol' || type == 'boolean' || - value == null || isSymbol(value)) { - return true; - } - return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || - (object != null && value in Object(object)); -} - -/** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ -function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); -} - -/** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ -function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); -} - -/** - * Converts `string` to a property path array. - * - * @private - * @param {string} string The string to convert. - * @returns {Array} Returns the property path array. - */ -var stringToPath = memoize(function(string) { - string = toString(string); - - var result = []; - if (reLeadingDot.test(string)) { - result.push(''); - } - string.replace(rePropName, function(match, number, quote, string) { - result.push(quote ? string.replace(reEscapeChar, '$1') : (number || match)); - }); - return result; -}); - -/** - * Converts `value` to a string key if it's not a string or symbol. - * - * @private - * @param {*} value The value to inspect. - * @returns {string|symbol} Returns the key. - */ -function toKey(value) { - if (typeof value == 'string' || isSymbol(value)) { - return value; - } - var result = (value + ''); - return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; -} - -/** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to process. - * @returns {string} Returns the source code. - */ -function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; -} - -/** - * Creates a function that memoizes the result of `func`. If `resolver` is - * provided, it determines the cache key for storing the result based on the - * arguments provided to the memoized function. By default, the first argument - * provided to the memoized function is used as the map cache key. The `func` - * is invoked with the `this` binding of the memoized function. - * - * **Note:** The cache is exposed as the `cache` property on the memoized - * function. Its creation may be customized by replacing the `_.memoize.Cache` - * constructor with one whose instances implement the - * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) - * method interface of `delete`, `get`, `has`, and `set`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Function - * @param {Function} func The function to have its output memoized. - * @param {Function} [resolver] The function to resolve the cache key. - * @returns {Function} Returns the new memoized function. - * @example - * - * var object = { 'a': 1, 'b': 2 }; - * var other = { 'c': 3, 'd': 4 }; - * - * var values = _.memoize(_.values); - * values(object); - * // => [1, 2] - * - * values(other); - * // => [3, 4] - * - * object.a = 2; - * values(object); - * // => [1, 2] - * - * // Modify the result cache. - * values.cache.set(object, ['a', 'b']); - * values(object); - * // => ['a', 'b'] - * - * // Replace `_.memoize.Cache`. - * _.memoize.Cache = WeakMap; - */ -function memoize(func, resolver) { - if (typeof func != 'function' || (resolver && typeof resolver != 'function')) { - throw new TypeError(FUNC_ERROR_TEXT); - } - var memoized = function() { - var args = arguments, - key = resolver ? resolver.apply(this, args) : args[0], - cache = memoized.cache; - - if (cache.has(key)) { - return cache.get(key); - } - var result = func.apply(this, args); - memoized.cache = cache.set(key, result); - return result; - }; - memoized.cache = new (memoize.Cache || MapCache); - return memoized; -} - -// Assign cache to `_.memoize`. -memoize.Cache = MapCache; - -/** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ -function eq(value, other) { - return value === other || (value !== value && other !== other); -} - -/** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ -var isArray = Array.isArray; - -/** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ -function isFunction(value) { - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 8-9 which returns 'object' for typed array and other constructors. - var tag = isObject(value) ? objectToString.call(value) : ''; - return tag == funcTag || tag == genTag; -} - -/** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ -function isObject(value) { - var type = typeof value; - return !!value && (type == 'object' || type == 'function'); -} - -/** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ -function isObjectLike(value) { - return !!value && typeof value == 'object'; -} - -/** - * Checks if `value` is classified as a `Symbol` primitive or object. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. - * @example - * - * _.isSymbol(Symbol.iterator); - * // => true - * - * _.isSymbol('abc'); - * // => false - */ -function isSymbol(value) { - return typeof value == 'symbol' || - (isObjectLike(value) && objectToString.call(value) == symbolTag); -} - -/** - * Converts `value` to a string. An empty string is returned for `null` - * and `undefined` values. The sign of `-0` is preserved. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to process. - * @returns {string} Returns the string. - * @example - * - * _.toString(null); - * // => '' - * - * _.toString(-0); - * // => '-0' - * - * _.toString([1, 2, 3]); - * // => '1,2,3' - */ -function toString(value) { - return value == null ? '' : baseToString(value); -} - -/** - * Gets the value at `path` of `object`. If the resolved value is - * `undefined`, the `defaultValue` is returned in its place. - * - * @static - * @memberOf _ - * @since 3.7.0 - * @category Object - * @param {Object} object The object to query. - * @param {Array|string} path The path of the property to get. - * @param {*} [defaultValue] The value returned for `undefined` resolved values. - * @returns {*} Returns the resolved value. - * @example - * - * var object = { 'a': [{ 'b': { 'c': 3 } }] }; - * - * _.get(object, 'a[0].b.c'); - * // => 3 - * - * _.get(object, ['a', '0', 'b', 'c']); - * // => 3 - * - * _.get(object, 'a.b.c', 'default'); - * // => 'default' - */ -function get(object, path, defaultValue) { - var result = object == null ? undefined : baseGet(object, path); - return result === undefined ? defaultValue : result; -} - -module.exports = get; - - -/***/ }), - -/***/ 2307: -/***/ (function(module, exports, __webpack_require__) { - -/* module decorator */ module = __webpack_require__.nmd(module); -/** - * Lodash (Custom Build) - * Build: `lodash modularize exports="npm" -o ./` - * Copyright JS Foundation and other contributors - * Released under MIT license - * Based on Underscore.js 1.8.3 - * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors - */ - -/** Used as the size to enable large array optimizations. */ -var LARGE_ARRAY_SIZE = 200; - -/** Used to stand-in for `undefined` hash values. */ -var HASH_UNDEFINED = '__lodash_hash_undefined__'; - -/** Used to compose bitmasks for value comparisons. */ -var COMPARE_PARTIAL_FLAG = 1, - COMPARE_UNORDERED_FLAG = 2; - -/** Used as references for various `Number` constants. */ -var MAX_SAFE_INTEGER = 9007199254740991; - -/** `Object#toString` result references. */ -var argsTag = '[object Arguments]', - arrayTag = '[object Array]', - asyncTag = '[object AsyncFunction]', - boolTag = '[object Boolean]', - dateTag = '[object Date]', - errorTag = '[object Error]', - funcTag = '[object Function]', - genTag = '[object GeneratorFunction]', - mapTag = '[object Map]', - numberTag = '[object Number]', - nullTag = '[object Null]', - objectTag = '[object Object]', - promiseTag = '[object Promise]', - proxyTag = '[object Proxy]', - regexpTag = '[object RegExp]', - setTag = '[object Set]', - stringTag = '[object String]', - symbolTag = '[object Symbol]', - undefinedTag = '[object Undefined]', - weakMapTag = '[object WeakMap]'; - -var arrayBufferTag = '[object ArrayBuffer]', - dataViewTag = '[object DataView]', - float32Tag = '[object Float32Array]', - float64Tag = '[object Float64Array]', - int8Tag = '[object Int8Array]', - int16Tag = '[object Int16Array]', - int32Tag = '[object Int32Array]', - uint8Tag = '[object Uint8Array]', - uint8ClampedTag = '[object Uint8ClampedArray]', - uint16Tag = '[object Uint16Array]', - uint32Tag = '[object Uint32Array]'; - -/** - * Used to match `RegExp` - * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). - */ -var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; - -/** Used to detect host constructors (Safari). */ -var reIsHostCtor = /^\[object .+?Constructor\]$/; - -/** Used to detect unsigned integer values. */ -var reIsUint = /^(?:0|[1-9]\d*)$/; - -/** Used to identify `toStringTag` values of typed arrays. */ -var typedArrayTags = {}; -typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = -typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = -typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = -typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = -typedArrayTags[uint32Tag] = true; -typedArrayTags[argsTag] = typedArrayTags[arrayTag] = -typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = -typedArrayTags[dataViewTag] = typedArrayTags[dateTag] = -typedArrayTags[errorTag] = typedArrayTags[funcTag] = -typedArrayTags[mapTag] = typedArrayTags[numberTag] = -typedArrayTags[objectTag] = typedArrayTags[regexpTag] = -typedArrayTags[setTag] = typedArrayTags[stringTag] = -typedArrayTags[weakMapTag] = false; - -/** Detect free variable `global` from Node.js. */ -var freeGlobal = typeof __webpack_require__.g == 'object' && __webpack_require__.g && __webpack_require__.g.Object === Object && __webpack_require__.g; - -/** Detect free variable `self`. */ -var freeSelf = typeof self == 'object' && self && self.Object === Object && self; - -/** Used as a reference to the global object. */ -var root = freeGlobal || freeSelf || Function('return this')(); - -/** Detect free variable `exports`. */ -var freeExports = true && exports && !exports.nodeType && exports; - -/** Detect free variable `module`. */ -var freeModule = freeExports && "object" == 'object' && module && !module.nodeType && module; - -/** Detect the popular CommonJS extension `module.exports`. */ -var moduleExports = freeModule && freeModule.exports === freeExports; - -/** Detect free variable `process` from Node.js. */ -var freeProcess = moduleExports && freeGlobal.process; - -/** Used to access faster Node.js helpers. */ -var nodeUtil = (function() { - try { - return freeProcess && freeProcess.binding && freeProcess.binding('util'); - } catch (e) {} -}()); - -/* Node.js helper references. */ -var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray; - -/** - * A specialized version of `_.filter` for arrays without support for - * iteratee shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {Array} Returns the new filtered array. - */ -function arrayFilter(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length, - resIndex = 0, - result = []; - - while (++index < length) { - var value = array[index]; - if (predicate(value, index, array)) { - result[resIndex++] = value; - } - } - return result; -} - -/** - * Appends the elements of `values` to `array`. - * - * @private - * @param {Array} array The array to modify. - * @param {Array} values The values to append. - * @returns {Array} Returns `array`. - */ -function arrayPush(array, values) { - var index = -1, - length = values.length, - offset = array.length; - - while (++index < length) { - array[offset + index] = values[index]; - } - return array; -} - -/** - * A specialized version of `_.some` for arrays without support for iteratee - * shorthands. - * - * @private - * @param {Array} [array] The array to iterate over. - * @param {Function} predicate The function invoked per iteration. - * @returns {boolean} Returns `true` if any element passes the predicate check, - * else `false`. - */ -function arraySome(array, predicate) { - var index = -1, - length = array == null ? 0 : array.length; - - while (++index < length) { - if (predicate(array[index], index, array)) { - return true; - } - } - return false; -} - -/** - * The base implementation of `_.times` without support for iteratee shorthands - * or max array length checks. - * - * @private - * @param {number} n The number of times to invoke `iteratee`. - * @param {Function} iteratee The function invoked per iteration. - * @returns {Array} Returns the array of results. - */ -function baseTimes(n, iteratee) { - var index = -1, - result = Array(n); - - while (++index < n) { - result[index] = iteratee(index); - } - return result; -} - -/** - * The base implementation of `_.unary` without support for storing metadata. - * - * @private - * @param {Function} func The function to cap arguments for. - * @returns {Function} Returns the new capped function. - */ -function baseUnary(func) { - return function(value) { - return func(value); - }; -} - -/** - * Checks if a `cache` value for `key` exists. - * - * @private - * @param {Object} cache The cache to query. - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function cacheHas(cache, key) { - return cache.has(key); -} - -/** - * Gets the value at `key` of `object`. - * - * @private - * @param {Object} [object] The object to query. - * @param {string} key The key of the property to get. - * @returns {*} Returns the property value. - */ -function getValue(object, key) { - return object == null ? undefined : object[key]; -} - -/** - * Converts `map` to its key-value pairs. - * - * @private - * @param {Object} map The map to convert. - * @returns {Array} Returns the key-value pairs. - */ -function mapToArray(map) { - var index = -1, - result = Array(map.size); - - map.forEach(function(value, key) { - result[++index] = [key, value]; - }); - return result; -} - -/** - * Creates a unary function that invokes `func` with its argument transformed. - * - * @private - * @param {Function} func The function to wrap. - * @param {Function} transform The argument transform. - * @returns {Function} Returns the new function. - */ -function overArg(func, transform) { - return function(arg) { - return func(transform(arg)); - }; -} - -/** - * Converts `set` to an array of its values. - * - * @private - * @param {Object} set The set to convert. - * @returns {Array} Returns the values. - */ -function setToArray(set) { - var index = -1, - result = Array(set.size); - - set.forEach(function(value) { - result[++index] = value; - }); - return result; -} - -/** Used for built-in method references. */ -var arrayProto = Array.prototype, - funcProto = Function.prototype, - objectProto = Object.prototype; - -/** Used to detect overreaching core-js shims. */ -var coreJsData = root['__core-js_shared__']; - -/** Used to resolve the decompiled source of functions. */ -var funcToString = funcProto.toString; - -/** Used to check objects for own properties. */ -var hasOwnProperty = objectProto.hasOwnProperty; - -/** Used to detect methods masquerading as native. */ -var maskSrcKey = (function() { - var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || ''); - return uid ? ('Symbol(src)_1.' + uid) : ''; -}()); - -/** - * Used to resolve the - * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) - * of values. - */ -var nativeObjectToString = objectProto.toString; - -/** Used to detect if a method is native. */ -var reIsNative = RegExp('^' + - funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\$&') - .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' -); - -/** Built-in value references. */ -var Buffer = moduleExports ? root.Buffer : undefined, - Symbol = root.Symbol, - Uint8Array = root.Uint8Array, - propertyIsEnumerable = objectProto.propertyIsEnumerable, - splice = arrayProto.splice, - symToStringTag = Symbol ? Symbol.toStringTag : undefined; - -/* Built-in method references for those with the same name as other `lodash` methods. */ -var nativeGetSymbols = Object.getOwnPropertySymbols, - nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined, - nativeKeys = overArg(Object.keys, Object); - -/* Built-in method references that are verified to be native. */ -var DataView = getNative(root, 'DataView'), - Map = getNative(root, 'Map'), - Promise = getNative(root, 'Promise'), - Set = getNative(root, 'Set'), - WeakMap = getNative(root, 'WeakMap'), - nativeCreate = getNative(Object, 'create'); - -/** Used to detect maps, sets, and weakmaps. */ -var dataViewCtorString = toSource(DataView), - mapCtorString = toSource(Map), - promiseCtorString = toSource(Promise), - setCtorString = toSource(Set), - weakMapCtorString = toSource(WeakMap); - -/** Used to convert symbols to primitives and strings. */ -var symbolProto = Symbol ? Symbol.prototype : undefined, - symbolValueOf = symbolProto ? symbolProto.valueOf : undefined; - -/** - * Creates a hash object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Hash(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the hash. - * - * @private - * @name clear - * @memberOf Hash - */ -function hashClear() { - this.__data__ = nativeCreate ? nativeCreate(null) : {}; - this.size = 0; -} - -/** - * Removes `key` and its value from the hash. - * - * @private - * @name delete - * @memberOf Hash - * @param {Object} hash The hash to modify. - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function hashDelete(key) { - var result = this.has(key) && delete this.__data__[key]; - this.size -= result ? 1 : 0; - return result; -} - -/** - * Gets the hash value for `key`. - * - * @private - * @name get - * @memberOf Hash - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function hashGet(key) { - var data = this.__data__; - if (nativeCreate) { - var result = data[key]; - return result === HASH_UNDEFINED ? undefined : result; - } - return hasOwnProperty.call(data, key) ? data[key] : undefined; -} - -/** - * Checks if a hash value for `key` exists. - * - * @private - * @name has - * @memberOf Hash - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function hashHas(key) { - var data = this.__data__; - return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key); -} - -/** - * Sets the hash `key` to `value`. - * - * @private - * @name set - * @memberOf Hash - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the hash instance. - */ -function hashSet(key, value) { - var data = this.__data__; - this.size += this.has(key) ? 0 : 1; - data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value; - return this; -} - -// Add methods to `Hash`. -Hash.prototype.clear = hashClear; -Hash.prototype['delete'] = hashDelete; -Hash.prototype.get = hashGet; -Hash.prototype.has = hashHas; -Hash.prototype.set = hashSet; - -/** - * Creates an list cache object. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function ListCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the list cache. - * - * @private - * @name clear - * @memberOf ListCache - */ -function listCacheClear() { - this.__data__ = []; - this.size = 0; -} - -/** - * Removes `key` and its value from the list cache. - * - * @private - * @name delete - * @memberOf ListCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function listCacheDelete(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - return false; - } - var lastIndex = data.length - 1; - if (index == lastIndex) { - data.pop(); - } else { - splice.call(data, index, 1); - } - --this.size; - return true; -} - -/** - * Gets the list cache value for `key`. - * - * @private - * @name get - * @memberOf ListCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function listCacheGet(key) { - var data = this.__data__, - index = assocIndexOf(data, key); - - return index < 0 ? undefined : data[index][1]; -} - -/** - * Checks if a list cache value for `key` exists. - * - * @private - * @name has - * @memberOf ListCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function listCacheHas(key) { - return assocIndexOf(this.__data__, key) > -1; -} - -/** - * Sets the list cache `key` to `value`. - * - * @private - * @name set - * @memberOf ListCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the list cache instance. - */ -function listCacheSet(key, value) { - var data = this.__data__, - index = assocIndexOf(data, key); - - if (index < 0) { - ++this.size; - data.push([key, value]); - } else { - data[index][1] = value; - } - return this; -} - -// Add methods to `ListCache`. -ListCache.prototype.clear = listCacheClear; -ListCache.prototype['delete'] = listCacheDelete; -ListCache.prototype.get = listCacheGet; -ListCache.prototype.has = listCacheHas; -ListCache.prototype.set = listCacheSet; - -/** - * Creates a map cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function MapCache(entries) { - var index = -1, - length = entries == null ? 0 : entries.length; - - this.clear(); - while (++index < length) { - var entry = entries[index]; - this.set(entry[0], entry[1]); - } -} - -/** - * Removes all key-value entries from the map. - * - * @private - * @name clear - * @memberOf MapCache - */ -function mapCacheClear() { - this.size = 0; - this.__data__ = { - 'hash': new Hash, - 'map': new (Map || ListCache), - 'string': new Hash - }; -} - -/** - * Removes `key` and its value from the map. - * - * @private - * @name delete - * @memberOf MapCache - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function mapCacheDelete(key) { - var result = getMapData(this, key)['delete'](key); - this.size -= result ? 1 : 0; - return result; -} - -/** - * Gets the map value for `key`. - * - * @private - * @name get - * @memberOf MapCache - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function mapCacheGet(key) { - return getMapData(this, key).get(key); -} - -/** - * Checks if a map value for `key` exists. - * - * @private - * @name has - * @memberOf MapCache - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function mapCacheHas(key) { - return getMapData(this, key).has(key); -} - -/** - * Sets the map `key` to `value`. - * - * @private - * @name set - * @memberOf MapCache - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the map cache instance. - */ -function mapCacheSet(key, value) { - var data = getMapData(this, key), - size = data.size; - - data.set(key, value); - this.size += data.size == size ? 0 : 1; - return this; -} - -// Add methods to `MapCache`. -MapCache.prototype.clear = mapCacheClear; -MapCache.prototype['delete'] = mapCacheDelete; -MapCache.prototype.get = mapCacheGet; -MapCache.prototype.has = mapCacheHas; -MapCache.prototype.set = mapCacheSet; - -/** - * - * Creates an array cache object to store unique values. - * - * @private - * @constructor - * @param {Array} [values] The values to cache. - */ -function SetCache(values) { - var index = -1, - length = values == null ? 0 : values.length; - - this.__data__ = new MapCache; - while (++index < length) { - this.add(values[index]); - } -} - -/** - * Adds `value` to the array cache. - * - * @private - * @name add - * @memberOf SetCache - * @alias push - * @param {*} value The value to cache. - * @returns {Object} Returns the cache instance. - */ -function setCacheAdd(value) { - this.__data__.set(value, HASH_UNDEFINED); - return this; -} - -/** - * Checks if `value` is in the array cache. - * - * @private - * @name has - * @memberOf SetCache - * @param {*} value The value to search for. - * @returns {number} Returns `true` if `value` is found, else `false`. - */ -function setCacheHas(value) { - return this.__data__.has(value); -} - -// Add methods to `SetCache`. -SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; -SetCache.prototype.has = setCacheHas; - -/** - * Creates a stack cache object to store key-value pairs. - * - * @private - * @constructor - * @param {Array} [entries] The key-value pairs to cache. - */ -function Stack(entries) { - var data = this.__data__ = new ListCache(entries); - this.size = data.size; -} - -/** - * Removes all key-value entries from the stack. - * - * @private - * @name clear - * @memberOf Stack - */ -function stackClear() { - this.__data__ = new ListCache; - this.size = 0; -} - -/** - * Removes `key` and its value from the stack. - * - * @private - * @name delete - * @memberOf Stack - * @param {string} key The key of the value to remove. - * @returns {boolean} Returns `true` if the entry was removed, else `false`. - */ -function stackDelete(key) { - var data = this.__data__, - result = data['delete'](key); - - this.size = data.size; - return result; -} - -/** - * Gets the stack value for `key`. - * - * @private - * @name get - * @memberOf Stack - * @param {string} key The key of the value to get. - * @returns {*} Returns the entry value. - */ -function stackGet(key) { - return this.__data__.get(key); -} - -/** - * Checks if a stack value for `key` exists. - * - * @private - * @name has - * @memberOf Stack - * @param {string} key The key of the entry to check. - * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. - */ -function stackHas(key) { - return this.__data__.has(key); -} - -/** - * Sets the stack `key` to `value`. - * - * @private - * @name set - * @memberOf Stack - * @param {string} key The key of the value to set. - * @param {*} value The value to set. - * @returns {Object} Returns the stack cache instance. - */ -function stackSet(key, value) { - var data = this.__data__; - if (data instanceof ListCache) { - var pairs = data.__data__; - if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) { - pairs.push([key, value]); - this.size = ++data.size; - return this; - } - data = this.__data__ = new MapCache(pairs); - } - data.set(key, value); - this.size = data.size; - return this; -} - -// Add methods to `Stack`. -Stack.prototype.clear = stackClear; -Stack.prototype['delete'] = stackDelete; -Stack.prototype.get = stackGet; -Stack.prototype.has = stackHas; -Stack.prototype.set = stackSet; - -/** - * Creates an array of the enumerable property names of the array-like `value`. - * - * @private - * @param {*} value The value to query. - * @param {boolean} inherited Specify returning inherited property names. - * @returns {Array} Returns the array of property names. - */ -function arrayLikeKeys(value, inherited) { - var isArr = isArray(value), - isArg = !isArr && isArguments(value), - isBuff = !isArr && !isArg && isBuffer(value), - isType = !isArr && !isArg && !isBuff && isTypedArray(value), - skipIndexes = isArr || isArg || isBuff || isType, - result = skipIndexes ? baseTimes(value.length, String) : [], - length = result.length; - - for (var key in value) { - if ((inherited || hasOwnProperty.call(value, key)) && - !(skipIndexes && ( - // Safari 9 has enumerable `arguments.length` in strict mode. - key == 'length' || - // Node.js 0.10 has enumerable non-index properties on buffers. - (isBuff && (key == 'offset' || key == 'parent')) || - // PhantomJS 2 has enumerable non-index properties on typed arrays. - (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || - // Skip index properties. - isIndex(key, length) - ))) { - result.push(key); - } - } - return result; -} - -/** - * Gets the index at which the `key` is found in `array` of key-value pairs. - * - * @private - * @param {Array} array The array to inspect. - * @param {*} key The key to search for. - * @returns {number} Returns the index of the matched value, else `-1`. - */ -function assocIndexOf(array, key) { - var length = array.length; - while (length--) { - if (eq(array[length][0], key)) { - return length; - } - } - return -1; -} - -/** - * The base implementation of `getAllKeys` and `getAllKeysIn` which uses - * `keysFunc` and `symbolsFunc` to get the enumerable property names and - * symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {Function} keysFunc The function to get the keys of `object`. - * @param {Function} symbolsFunc The function to get the symbols of `object`. - * @returns {Array} Returns the array of property names and symbols. - */ -function baseGetAllKeys(object, keysFunc, symbolsFunc) { - var result = keysFunc(object); - return isArray(object) ? result : arrayPush(result, symbolsFunc(object)); -} - -/** - * The base implementation of `getTag` without fallbacks for buggy environments. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ -function baseGetTag(value) { - if (value == null) { - return value === undefined ? undefinedTag : nullTag; - } - return (symToStringTag && symToStringTag in Object(value)) - ? getRawTag(value) - : objectToString(value); -} - -/** - * The base implementation of `_.isArguments`. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - */ -function baseIsArguments(value) { - return isObjectLike(value) && baseGetTag(value) == argsTag; -} - -/** - * The base implementation of `_.isEqual` which supports partial comparisons - * and tracks traversed objects. - * - * @private - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @param {boolean} bitmask The bitmask flags. - * 1 - Unordered comparison - * 2 - Partial comparison - * @param {Function} [customizer] The function to customize comparisons. - * @param {Object} [stack] Tracks traversed `value` and `other` objects. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - */ -function baseIsEqual(value, other, bitmask, customizer, stack) { - if (value === other) { - return true; - } - if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { - return value !== value && other !== other; - } - return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); -} - -/** - * A specialized version of `baseIsEqual` for arrays and objects which performs - * deep comparisons and tracks traversed objects enabling objects with circular - * references to be compared. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} [stack] Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { - var objIsArr = isArray(object), - othIsArr = isArray(other), - objTag = objIsArr ? arrayTag : getTag(object), - othTag = othIsArr ? arrayTag : getTag(other); - - objTag = objTag == argsTag ? objectTag : objTag; - othTag = othTag == argsTag ? objectTag : othTag; - - var objIsObj = objTag == objectTag, - othIsObj = othTag == objectTag, - isSameTag = objTag == othTag; - - if (isSameTag && isBuffer(object)) { - if (!isBuffer(other)) { - return false; - } - objIsArr = true; - objIsObj = false; - } - if (isSameTag && !objIsObj) { - stack || (stack = new Stack); - return (objIsArr || isTypedArray(object)) - ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) - : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); - } - if (!(bitmask & COMPARE_PARTIAL_FLAG)) { - var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'), - othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__'); - - if (objIsWrapped || othIsWrapped) { - var objUnwrapped = objIsWrapped ? object.value() : object, - othUnwrapped = othIsWrapped ? other.value() : other; - - stack || (stack = new Stack); - return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); - } - } - if (!isSameTag) { - return false; - } - stack || (stack = new Stack); - return equalObjects(object, other, bitmask, customizer, equalFunc, stack); -} - -/** - * The base implementation of `_.isNative` without bad shim checks. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a native function, - * else `false`. - */ -function baseIsNative(value) { - if (!isObject(value) || isMasked(value)) { - return false; - } - var pattern = isFunction(value) ? reIsNative : reIsHostCtor; - return pattern.test(toSource(value)); -} - -/** - * The base implementation of `_.isTypedArray` without Node.js optimizations. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - */ -function baseIsTypedArray(value) { - return isObjectLike(value) && - isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; -} - -/** - * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - */ -function baseKeys(object) { - if (!isPrototype(object)) { - return nativeKeys(object); - } - var result = []; - for (var key in Object(object)) { - if (hasOwnProperty.call(object, key) && key != 'constructor') { - result.push(key); - } - } - return result; -} - -/** - * A specialized version of `baseIsEqualDeep` for arrays with support for - * partial deep comparisons. - * - * @private - * @param {Array} array The array to compare. - * @param {Array} other The other array to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `array` and `other` objects. - * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. - */ -function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - arrLength = array.length, - othLength = other.length; - - if (arrLength != othLength && !(isPartial && othLength > arrLength)) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(array); - if (stacked && stack.get(other)) { - return stacked == other; - } - var index = -1, - result = true, - seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined; - - stack.set(array, other); - stack.set(other, array); - - // Ignore non-index properties. - while (++index < arrLength) { - var arrValue = array[index], - othValue = other[index]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, arrValue, index, other, array, stack) - : customizer(arrValue, othValue, index, array, other, stack); - } - if (compared !== undefined) { - if (compared) { - continue; - } - result = false; - break; - } - // Recursively compare arrays (susceptible to call stack limits). - if (seen) { - if (!arraySome(other, function(othValue, othIndex) { - if (!cacheHas(seen, othIndex) && - (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { - return seen.push(othIndex); - } - })) { - result = false; - break; - } - } else if (!( - arrValue === othValue || - equalFunc(arrValue, othValue, bitmask, customizer, stack) - )) { - result = false; - break; - } - } - stack['delete'](array); - stack['delete'](other); - return result; -} - -/** - * A specialized version of `baseIsEqualDeep` for comparing objects of - * the same `toStringTag`. - * - * **Note:** This function only supports comparing values with tags of - * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {string} tag The `toStringTag` of the objects to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { - switch (tag) { - case dataViewTag: - if ((object.byteLength != other.byteLength) || - (object.byteOffset != other.byteOffset)) { - return false; - } - object = object.buffer; - other = other.buffer; - - case arrayBufferTag: - if ((object.byteLength != other.byteLength) || - !equalFunc(new Uint8Array(object), new Uint8Array(other))) { - return false; - } - return true; - - case boolTag: - case dateTag: - case numberTag: - // Coerce booleans to `1` or `0` and dates to milliseconds. - // Invalid dates are coerced to `NaN`. - return eq(+object, +other); - - case errorTag: - return object.name == other.name && object.message == other.message; - - case regexpTag: - case stringTag: - // Coerce regexes to strings and treat strings, primitives and objects, - // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring - // for more details. - return object == (other + ''); - - case mapTag: - var convert = mapToArray; - - case setTag: - var isPartial = bitmask & COMPARE_PARTIAL_FLAG; - convert || (convert = setToArray); - - if (object.size != other.size && !isPartial) { - return false; - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked) { - return stacked == other; - } - bitmask |= COMPARE_UNORDERED_FLAG; - - // Recursively compare objects (susceptible to call stack limits). - stack.set(object, other); - var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); - stack['delete'](object); - return result; - - case symbolTag: - if (symbolValueOf) { - return symbolValueOf.call(object) == symbolValueOf.call(other); - } - } - return false; -} - -/** - * A specialized version of `baseIsEqualDeep` for objects with support for - * partial deep comparisons. - * - * @private - * @param {Object} object The object to compare. - * @param {Object} other The other object to compare. - * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. - * @param {Function} customizer The function to customize comparisons. - * @param {Function} equalFunc The function to determine equivalents of values. - * @param {Object} stack Tracks traversed `object` and `other` objects. - * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. - */ -function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { - var isPartial = bitmask & COMPARE_PARTIAL_FLAG, - objProps = getAllKeys(object), - objLength = objProps.length, - othProps = getAllKeys(other), - othLength = othProps.length; - - if (objLength != othLength && !isPartial) { - return false; - } - var index = objLength; - while (index--) { - var key = objProps[index]; - if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) { - return false; - } - } - // Assume cyclic values are equal. - var stacked = stack.get(object); - if (stacked && stack.get(other)) { - return stacked == other; - } - var result = true; - stack.set(object, other); - stack.set(other, object); - - var skipCtor = isPartial; - while (++index < objLength) { - key = objProps[index]; - var objValue = object[key], - othValue = other[key]; - - if (customizer) { - var compared = isPartial - ? customizer(othValue, objValue, key, other, object, stack) - : customizer(objValue, othValue, key, object, other, stack); - } - // Recursively compare objects (susceptible to call stack limits). - if (!(compared === undefined - ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) - : compared - )) { - result = false; - break; - } - skipCtor || (skipCtor = key == 'constructor'); - } - if (result && !skipCtor) { - var objCtor = object.constructor, - othCtor = other.constructor; - - // Non `Object` object instances with different constructors are not equal. - if (objCtor != othCtor && - ('constructor' in object && 'constructor' in other) && - !(typeof objCtor == 'function' && objCtor instanceof objCtor && - typeof othCtor == 'function' && othCtor instanceof othCtor)) { - result = false; - } - } - stack['delete'](object); - stack['delete'](other); - return result; -} - -/** - * Creates an array of own enumerable property names and symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names and symbols. - */ -function getAllKeys(object) { - return baseGetAllKeys(object, keys, getSymbols); -} - -/** - * Gets the data for `map`. - * - * @private - * @param {Object} map The map to query. - * @param {string} key The reference key. - * @returns {*} Returns the map data. - */ -function getMapData(map, key) { - var data = map.__data__; - return isKeyable(key) - ? data[typeof key == 'string' ? 'string' : 'hash'] - : data.map; -} - -/** - * Gets the native function at `key` of `object`. - * - * @private - * @param {Object} object The object to query. - * @param {string} key The key of the method to get. - * @returns {*} Returns the function if it's native, else `undefined`. - */ -function getNative(object, key) { - var value = getValue(object, key); - return baseIsNative(value) ? value : undefined; -} - -/** - * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the raw `toStringTag`. - */ -function getRawTag(value) { - var isOwn = hasOwnProperty.call(value, symToStringTag), - tag = value[symToStringTag]; - - try { - value[symToStringTag] = undefined; - var unmasked = true; - } catch (e) {} - - var result = nativeObjectToString.call(value); - if (unmasked) { - if (isOwn) { - value[symToStringTag] = tag; - } else { - delete value[symToStringTag]; - } - } - return result; -} - -/** - * Creates an array of the own enumerable symbols of `object`. - * - * @private - * @param {Object} object The object to query. - * @returns {Array} Returns the array of symbols. - */ -var getSymbols = !nativeGetSymbols ? stubArray : function(object) { - if (object == null) { - return []; - } - object = Object(object); - return arrayFilter(nativeGetSymbols(object), function(symbol) { - return propertyIsEnumerable.call(object, symbol); - }); -}; - -/** - * Gets the `toStringTag` of `value`. - * - * @private - * @param {*} value The value to query. - * @returns {string} Returns the `toStringTag`. - */ -var getTag = baseGetTag; - -// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. -if ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) || - (Map && getTag(new Map) != mapTag) || - (Promise && getTag(Promise.resolve()) != promiseTag) || - (Set && getTag(new Set) != setTag) || - (WeakMap && getTag(new WeakMap) != weakMapTag)) { - getTag = function(value) { - var result = baseGetTag(value), - Ctor = result == objectTag ? value.constructor : undefined, - ctorString = Ctor ? toSource(Ctor) : ''; - - if (ctorString) { - switch (ctorString) { - case dataViewCtorString: return dataViewTag; - case mapCtorString: return mapTag; - case promiseCtorString: return promiseTag; - case setCtorString: return setTag; - case weakMapCtorString: return weakMapTag; - } - } - return result; - }; -} - -/** - * Checks if `value` is a valid array-like index. - * - * @private - * @param {*} value The value to check. - * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. - * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. - */ -function isIndex(value, length) { - length = length == null ? MAX_SAFE_INTEGER : length; - return !!length && - (typeof value == 'number' || reIsUint.test(value)) && - (value > -1 && value % 1 == 0 && value < length); -} - -/** - * Checks if `value` is suitable for use as unique object key. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is suitable, else `false`. - */ -function isKeyable(value) { - var type = typeof value; - return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') - ? (value !== '__proto__') - : (value === null); -} - -/** - * Checks if `func` has its source masked. - * - * @private - * @param {Function} func The function to check. - * @returns {boolean} Returns `true` if `func` is masked, else `false`. - */ -function isMasked(func) { - return !!maskSrcKey && (maskSrcKey in func); -} - -/** - * Checks if `value` is likely a prototype object. - * - * @private - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. - */ -function isPrototype(value) { - var Ctor = value && value.constructor, - proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto; - - return value === proto; -} - -/** - * Converts `value` to a string using `Object.prototype.toString`. - * - * @private - * @param {*} value The value to convert. - * @returns {string} Returns the converted string. - */ -function objectToString(value) { - return nativeObjectToString.call(value); -} - -/** - * Converts `func` to its source code. - * - * @private - * @param {Function} func The function to convert. - * @returns {string} Returns the source code. - */ -function toSource(func) { - if (func != null) { - try { - return funcToString.call(func); - } catch (e) {} - try { - return (func + ''); - } catch (e) {} - } - return ''; -} - -/** - * Performs a - * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) - * comparison between two values to determine if they are equivalent. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.eq(object, object); - * // => true - * - * _.eq(object, other); - * // => false - * - * _.eq('a', 'a'); - * // => true - * - * _.eq('a', Object('a')); - * // => false - * - * _.eq(NaN, NaN); - * // => true - */ -function eq(value, other) { - return value === other || (value !== value && other !== other); -} - -/** - * Checks if `value` is likely an `arguments` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an `arguments` object, - * else `false`. - * @example - * - * _.isArguments(function() { return arguments; }()); - * // => true - * - * _.isArguments([1, 2, 3]); - * // => false - */ -var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { - return isObjectLike(value) && hasOwnProperty.call(value, 'callee') && - !propertyIsEnumerable.call(value, 'callee'); -}; - -/** - * Checks if `value` is classified as an `Array` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an array, else `false`. - * @example - * - * _.isArray([1, 2, 3]); - * // => true - * - * _.isArray(document.body.children); - * // => false - * - * _.isArray('abc'); - * // => false - * - * _.isArray(_.noop); - * // => false - */ -var isArray = Array.isArray; - -/** - * Checks if `value` is array-like. A value is considered array-like if it's - * not a function and has a `value.length` that's an integer greater than or - * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is array-like, else `false`. - * @example - * - * _.isArrayLike([1, 2, 3]); - * // => true - * - * _.isArrayLike(document.body.children); - * // => true - * - * _.isArrayLike('abc'); - * // => true - * - * _.isArrayLike(_.noop); - * // => false - */ -function isArrayLike(value) { - return value != null && isLength(value.length) && !isFunction(value); -} - -/** - * Checks if `value` is a buffer. - * - * @static - * @memberOf _ - * @since 4.3.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. - * @example - * - * _.isBuffer(new Buffer(2)); - * // => true - * - * _.isBuffer(new Uint8Array(2)); - * // => false - */ -var isBuffer = nativeIsBuffer || stubFalse; - -/** - * Performs a deep comparison between two values to determine if they are - * equivalent. - * - * **Note:** This method supports comparing arrays, array buffers, booleans, - * date objects, error objects, maps, numbers, `Object` objects, regexes, - * sets, strings, symbols, and typed arrays. `Object` objects are compared - * by their own, not inherited, enumerable properties. Functions and DOM - * nodes are compared by strict equality, i.e. `===`. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to compare. - * @param {*} other The other value to compare. - * @returns {boolean} Returns `true` if the values are equivalent, else `false`. - * @example - * - * var object = { 'a': 1 }; - * var other = { 'a': 1 }; - * - * _.isEqual(object, other); - * // => true - * - * object === other; - * // => false - */ -function isEqual(value, other) { - return baseIsEqual(value, other); -} - -/** - * Checks if `value` is classified as a `Function` object. - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a function, else `false`. - * @example - * - * _.isFunction(_); - * // => true - * - * _.isFunction(/abc/); - * // => false - */ -function isFunction(value) { - if (!isObject(value)) { - return false; - } - // The use of `Object#toString` avoids issues with the `typeof` operator - // in Safari 9 which returns 'object' for typed arrays and other constructors. - var tag = baseGetTag(value); - return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag; -} - -/** - * Checks if `value` is a valid array-like length. - * - * **Note:** This method is loosely based on - * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. - * @example - * - * _.isLength(3); - * // => true - * - * _.isLength(Number.MIN_VALUE); - * // => false - * - * _.isLength(Infinity); - * // => false - * - * _.isLength('3'); - * // => false - */ -function isLength(value) { - return typeof value == 'number' && - value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER; -} - -/** - * Checks if `value` is the - * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) - * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) - * - * @static - * @memberOf _ - * @since 0.1.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is an object, else `false`. - * @example - * - * _.isObject({}); - * // => true - * - * _.isObject([1, 2, 3]); - * // => true - * - * _.isObject(_.noop); - * // => true - * - * _.isObject(null); - * // => false - */ -function isObject(value) { - var type = typeof value; - return value != null && (type == 'object' || type == 'function'); -} - -/** - * Checks if `value` is object-like. A value is object-like if it's not `null` - * and has a `typeof` result of "object". - * - * @static - * @memberOf _ - * @since 4.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is object-like, else `false`. - * @example - * - * _.isObjectLike({}); - * // => true - * - * _.isObjectLike([1, 2, 3]); - * // => true - * - * _.isObjectLike(_.noop); - * // => false - * - * _.isObjectLike(null); - * // => false - */ -function isObjectLike(value) { - return value != null && typeof value == 'object'; -} - -/** - * Checks if `value` is classified as a typed array. - * - * @static - * @memberOf _ - * @since 3.0.0 - * @category Lang - * @param {*} value The value to check. - * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. - * @example - * - * _.isTypedArray(new Uint8Array); - * // => true - * - * _.isTypedArray([]); - * // => false - */ -var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; - -/** - * Creates an array of the own enumerable property names of `object`. - * - * **Note:** Non-object values are coerced to objects. See the - * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) - * for more details. - * - * @static - * @since 0.1.0 - * @memberOf _ - * @category Object - * @param {Object} object The object to query. - * @returns {Array} Returns the array of property names. - * @example - * - * function Foo() { - * this.a = 1; - * this.b = 2; - * } - * - * Foo.prototype.c = 3; - * - * _.keys(new Foo); - * // => ['a', 'b'] (iteration order is not guaranteed) - * - * _.keys('hi'); - * // => ['0', '1'] - */ -function keys(object) { - return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); -} - -/** - * This method returns a new empty array. - * - * @static - * @memberOf _ - * @since 4.13.0 - * @category Util - * @returns {Array} Returns the new empty array. - * @example - * - * var arrays = _.times(2, _.stubArray); - * - * console.log(arrays); - * // => [[], []] - * - * console.log(arrays[0] === arrays[1]); - * // => false - */ -function stubArray() { - return []; -} - -/** - * This method returns `false`. - * - * @static - * @memberOf _ - * @since 4.13.0 - * @category Util - * @returns {boolean} Returns `false`. - * @example - * - * _.times(2, _.stubFalse); - * // => [false, false] - */ -function stubFalse() { - return false; -} - -module.exports = isEqual; - - -/***/ }), - -/***/ 2703: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -"use strict"; -/** - * Copyright (c) 2013-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - - - -var ReactPropTypesSecret = __webpack_require__(414); - -function emptyFunction() {} -function emptyFunctionWithReset() {} -emptyFunctionWithReset.resetWarningCache = emptyFunction; - -module.exports = function() { - function shim(props, propName, componentName, location, propFullName, secret) { - if (secret === ReactPropTypesSecret) { - // It is still safe when called from React. - return; - } - var err = new Error( - 'Calling PropTypes validators directly is not supported by the `prop-types` package. ' + - 'Use PropTypes.checkPropTypes() to call them. ' + - 'Read more at http://fb.me/use-check-prop-types' - ); - err.name = 'Invariant Violation'; - throw err; - }; - shim.isRequired = shim; - function getShim() { - return shim; - }; - // Important! - // Keep this list in sync with production version in `./factoryWithTypeCheckers.js`. - var ReactPropTypes = { - array: shim, - bigint: shim, - bool: shim, - func: shim, - number: shim, - object: shim, - string: shim, - symbol: shim, - - any: shim, - arrayOf: getShim, - element: shim, - elementType: shim, - instanceOf: getShim, - node: shim, - objectOf: getShim, - oneOf: getShim, - oneOfType: getShim, - shape: getShim, - exact: getShim, - - checkPropTypes: emptyFunctionWithReset, - resetWarningCache: emptyFunction - }; - - ReactPropTypes.PropTypes = ReactPropTypes; - - return ReactPropTypes; -}; - - -/***/ }), - -/***/ 5697: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -/** - * Copyright (c) 2013-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - -if (false) { var throwOnDirectAccess, ReactIs; } else { - // By explicitly using `prop-types` you are opting into new production behavior. - // http://fb.me/prop-types-in-prod - module.exports = __webpack_require__(2703)(); -} - - -/***/ }), - -/***/ 414: -/***/ (function(module) { - -"use strict"; -/** - * Copyright (c) 2013-present, Facebook, Inc. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ - - - -var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED'; - -module.exports = ReactPropTypesSecret; - - -/***/ }), - -/***/ 3946: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -var __extends = (this && this.__extends) || (function () { - var extendStatics = function (d, b) { - extendStatics = Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || - function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; - return extendStatics(d, b); - }; - return function (d, b) { - if (typeof b !== "function" && b !== null) - throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); - extendStatics(d, b); - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); - }; -})(); -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -var ace_builds_1 = __webpack_require__(3239); -var PropTypes = __webpack_require__(5697); -var React = __webpack_require__(7294); -var isEqual = __webpack_require__(2307); -var editorOptions_1 = __webpack_require__(1048); -var ace = (0, editorOptions_1.getAceInstance)(); -var ReactAce = /** @class */ (function (_super) { - __extends(ReactAce, _super); - function ReactAce(props) { - var _this = _super.call(this, props) || this; - editorOptions_1.editorEvents.forEach(function (method) { - _this[method] = _this[method].bind(_this); - }); - _this.debounce = editorOptions_1.debounce; - return _this; - } - ReactAce.prototype.isInShadow = function (node) { - var parent = node && node.parentNode; - while (parent) { - if (parent.toString() === "[object ShadowRoot]") { - return true; - } - parent = parent.parentNode; - } - return false; - }; - ReactAce.prototype.componentDidMount = function () { - var _this = this; - var _a = this.props, className = _a.className, onBeforeLoad = _a.onBeforeLoad, onValidate = _a.onValidate, mode = _a.mode, focus = _a.focus, theme = _a.theme, fontSize = _a.fontSize, value = _a.value, defaultValue = _a.defaultValue, showGutter = _a.showGutter, wrapEnabled = _a.wrapEnabled, showPrintMargin = _a.showPrintMargin, _b = _a.scrollMargin, scrollMargin = _b === void 0 ? [0, 0, 0, 0] : _b, keyboardHandler = _a.keyboardHandler, onLoad = _a.onLoad, commands = _a.commands, annotations = _a.annotations, markers = _a.markers, placeholder = _a.placeholder; - this.editor = ace.edit(this.refEditor); - if (onBeforeLoad) { - onBeforeLoad(ace); - } - var editorProps = Object.keys(this.props.editorProps); - for (var i = 0; i < editorProps.length; i++) { - this.editor[editorProps[i]] = this.props.editorProps[editorProps[i]]; - } - if (this.props.debounceChangePeriod) { - this.onChange = this.debounce(this.onChange, this.props.debounceChangePeriod); - } - this.editor.renderer.setScrollMargin(scrollMargin[0], scrollMargin[1], scrollMargin[2], scrollMargin[3]); - if (this.isInShadow(this.refEditor)) { - this.editor.renderer.attachToShadowRoot(); - } - this.editor - .getSession() - .setMode(typeof mode === "string" ? "ace/mode/" + mode : mode); - if (theme && theme !== "") - this.editor.setTheme("ace/theme/" + theme); - this.editor.setFontSize(typeof fontSize === "number" ? fontSize + "px" : fontSize); - this.editor - .getSession() - .setValue(!defaultValue ? value || "" : defaultValue); - if (this.props.navigateToFileEnd) { - this.editor.navigateFileEnd(); - } - this.editor.renderer.setShowGutter(showGutter); - this.editor.getSession().setUseWrapMode(wrapEnabled); - this.editor.setShowPrintMargin(showPrintMargin); - this.editor.on("focus", this.onFocus); - this.editor.on("blur", this.onBlur); - this.editor.on("copy", this.onCopy); - this.editor.on("paste", this.onPaste); - this.editor.on("change", this.onChange); - this.editor.on("input", this.onInput); - if (placeholder) { - this.updatePlaceholder(); - } - this.editor - .getSession() - .selection.on("changeSelection", this.onSelectionChange); - this.editor.getSession().selection.on("changeCursor", this.onCursorChange); - if (onValidate) { - // @ts-ignore types don't include - this.editor.getSession().on("changeAnnotation", function () { - // tslint:disable-next-line:no-shadowed-variable - var annotations = _this.editor.getSession().getAnnotations(); - _this.props.onValidate(annotations); - }); - } - this.editor.session.on("changeScrollTop", this.onScroll); - this.editor.getSession().setAnnotations(annotations || []); - if (markers && markers.length > 0) { - this.handleMarkers(markers); - } - // get a list of possible options to avoid 'misspelled option errors' - var availableOptions = this.editor.$options; - editorOptions_1.editorOptions.forEach(function (option) { - if (availableOptions.hasOwnProperty(option)) { - // @ts-ignore - _this.editor.setOption(option, _this.props[option]); - } - else if (_this.props[option]) { - console.warn("ReactAce: editor option " + option + " was activated but not found. Did you need to import a related tool or did you possibly mispell the option?"); - } - }); - this.handleOptions(this.props); - if (Array.isArray(commands)) { - commands.forEach(function (command) { - if (typeof command.exec === "string") { - _this.editor.commands.bindKey(command.bindKey, command.exec); - } - else { - _this.editor.commands.addCommand(command); - } - }); - } - if (keyboardHandler) { - this.editor.setKeyboardHandler("ace/keyboard/" + keyboardHandler); - } - if (className) { - this.refEditor.className += " " + className; - } - if (onLoad) { - onLoad(this.editor); - } - this.editor.resize(); - if (focus) { - this.editor.focus(); - } - }; - ReactAce.prototype.componentDidUpdate = function (prevProps) { - var oldProps = prevProps; - var nextProps = this.props; - for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { - var option = editorOptions_1.editorOptions[i]; - if (nextProps[option] !== oldProps[option]) { - // @ts-ignore - this.editor.setOption(option, nextProps[option]); - } - } - if (nextProps.className !== oldProps.className) { - var appliedClasses = this.refEditor.className; - var appliedClassesArray_1 = appliedClasses.trim().split(" "); - var oldClassesArray = oldProps.className.trim().split(" "); - oldClassesArray.forEach(function (oldClass) { - var index = appliedClassesArray_1.indexOf(oldClass); - appliedClassesArray_1.splice(index, 1); - }); - this.refEditor.className = - " " + nextProps.className + " " + appliedClassesArray_1.join(" "); - } - // First process editor value, as it may create a new session (see issue #300) - if (this.editor && - nextProps.value != null && - this.editor.getValue() !== nextProps.value) { - // editor.setValue is a synchronous function call, change event is emitted before setValue return. - this.silent = true; - var pos = this.editor.session.selection.toJSON(); - this.editor.setValue(nextProps.value, nextProps.cursorStart); - this.editor.session.selection.fromJSON(pos); - this.silent = false; - } - if (nextProps.placeholder !== oldProps.placeholder) { - this.updatePlaceholder(); - } - if (nextProps.mode !== oldProps.mode) { - this.editor - .getSession() - .setMode(typeof nextProps.mode === "string" - ? "ace/mode/" + nextProps.mode - : nextProps.mode); - } - if (nextProps.theme !== oldProps.theme) { - this.editor.setTheme("ace/theme/" + nextProps.theme); - } - if (nextProps.keyboardHandler !== oldProps.keyboardHandler) { - if (nextProps.keyboardHandler) { - this.editor.setKeyboardHandler("ace/keyboard/" + nextProps.keyboardHandler); - } - else { - this.editor.setKeyboardHandler(null); - } - } - if (nextProps.fontSize !== oldProps.fontSize) { - this.editor.setFontSize(typeof nextProps.fontSize === "number" - ? nextProps.fontSize + "px" - : nextProps.fontSize); - } - if (nextProps.wrapEnabled !== oldProps.wrapEnabled) { - this.editor.getSession().setUseWrapMode(nextProps.wrapEnabled); - } - if (nextProps.showPrintMargin !== oldProps.showPrintMargin) { - this.editor.setShowPrintMargin(nextProps.showPrintMargin); - } - if (nextProps.showGutter !== oldProps.showGutter) { - this.editor.renderer.setShowGutter(nextProps.showGutter); - } - if (!isEqual(nextProps.setOptions, oldProps.setOptions)) { - this.handleOptions(nextProps); - } - if (!isEqual(nextProps.annotations, oldProps.annotations)) { - this.editor.getSession().setAnnotations(nextProps.annotations || []); - } - if (!isEqual(nextProps.markers, oldProps.markers) && - Array.isArray(nextProps.markers)) { - this.handleMarkers(nextProps.markers); - } - // this doesn't look like it works at all.... - if (!isEqual(nextProps.scrollMargin, oldProps.scrollMargin)) { - this.handleScrollMargins(nextProps.scrollMargin); - } - if (prevProps.height !== this.props.height || - prevProps.width !== this.props.width) { - this.editor.resize(); - } - if (this.props.focus && !prevProps.focus) { - this.editor.focus(); - } - }; - ReactAce.prototype.handleScrollMargins = function (margins) { - if (margins === void 0) { margins = [0, 0, 0, 0]; } - this.editor.renderer.setScrollMargin(margins[0], margins[1], margins[2], margins[3]); - }; - ReactAce.prototype.componentWillUnmount = function () { - this.editor.destroy(); - this.editor = null; - }; - ReactAce.prototype.onChange = function (event) { - if (this.props.onChange && !this.silent) { - var value = this.editor.getValue(); - this.props.onChange(value, event); - } - }; - ReactAce.prototype.onSelectionChange = function (event) { - if (this.props.onSelectionChange) { - var value = this.editor.getSelection(); - this.props.onSelectionChange(value, event); - } - }; - ReactAce.prototype.onCursorChange = function (event) { - if (this.props.onCursorChange) { - var value = this.editor.getSelection(); - this.props.onCursorChange(value, event); - } - }; - ReactAce.prototype.onInput = function (event) { - if (this.props.onInput) { - this.props.onInput(event); - } - if (this.props.placeholder) { - this.updatePlaceholder(); - } - }; - ReactAce.prototype.onFocus = function (event) { - if (this.props.onFocus) { - this.props.onFocus(event, this.editor); - } - }; - ReactAce.prototype.onBlur = function (event) { - if (this.props.onBlur) { - this.props.onBlur(event, this.editor); - } - }; - ReactAce.prototype.onCopy = function (_a) { - var text = _a.text; - if (this.props.onCopy) { - this.props.onCopy(text); - } - }; - ReactAce.prototype.onPaste = function (_a) { - var text = _a.text; - if (this.props.onPaste) { - this.props.onPaste(text); - } - }; - ReactAce.prototype.onScroll = function () { - if (this.props.onScroll) { - this.props.onScroll(this.editor); - } - }; - ReactAce.prototype.handleOptions = function (props) { - var setOptions = Object.keys(props.setOptions); - for (var y = 0; y < setOptions.length; y++) { - // @ts-ignore - this.editor.setOption(setOptions[y], props.setOptions[setOptions[y]]); - } - }; - ReactAce.prototype.handleMarkers = function (markers) { - var _this = this; - // remove foreground markers - var currentMarkers = this.editor.getSession().getMarkers(true); - for (var i in currentMarkers) { - if (currentMarkers.hasOwnProperty(i)) { - this.editor.getSession().removeMarker(currentMarkers[i].id); - } - } - // remove background markers except active line marker and selected word marker - currentMarkers = this.editor.getSession().getMarkers(false); - for (var i in currentMarkers) { - if (currentMarkers.hasOwnProperty(i) && - currentMarkers[i].clazz !== "ace_active-line" && - currentMarkers[i].clazz !== "ace_selected-word") { - this.editor.getSession().removeMarker(currentMarkers[i].id); - } - } - // add new markers - markers.forEach(function (_a) { - var startRow = _a.startRow, startCol = _a.startCol, endRow = _a.endRow, endCol = _a.endCol, className = _a.className, type = _a.type, _b = _a.inFront, inFront = _b === void 0 ? false : _b; - var range = new ace_builds_1.Range(startRow, startCol, endRow, endCol); - _this.editor.getSession().addMarker(range, className, type, inFront); - }); - }; - ReactAce.prototype.updatePlaceholder = function () { - // Adapted from https://stackoverflow.com/questions/26695708/how-can-i-add-placeholder-text-when-the-editor-is-empty - var editor = this.editor; - var placeholder = this.props.placeholder; - var showPlaceholder = !editor.session.getValue().length; - var node = editor.renderer.placeholderNode; - if (!showPlaceholder && node) { - editor.renderer.scroller.removeChild(editor.renderer.placeholderNode); - editor.renderer.placeholderNode = null; - } - else if (showPlaceholder && !node) { - node = editor.renderer.placeholderNode = document.createElement("div"); - node.textContent = placeholder || ""; - node.className = "ace_comment ace_placeholder"; - node.style.padding = "0 9px"; - node.style.position = "absolute"; - node.style.zIndex = "3"; - editor.renderer.scroller.appendChild(node); - } - else if (showPlaceholder && node) { - node.textContent = placeholder; - } - }; - ReactAce.prototype.updateRef = function (item) { - this.refEditor = item; - }; - ReactAce.prototype.render = function () { - var _a = this.props, name = _a.name, width = _a.width, height = _a.height, style = _a.style; - var divStyle = __assign({ width: width, height: height }, style); - return React.createElement("div", { ref: this.updateRef, id: name, style: divStyle }); - }; - ReactAce.propTypes = { - mode: PropTypes.oneOfType([PropTypes.string, PropTypes.object]), - focus: PropTypes.bool, - theme: PropTypes.string, - name: PropTypes.string, - className: PropTypes.string, - height: PropTypes.string, - width: PropTypes.string, - fontSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]), - showGutter: PropTypes.bool, - onChange: PropTypes.func, - onCopy: PropTypes.func, - onPaste: PropTypes.func, - onFocus: PropTypes.func, - onInput: PropTypes.func, - onBlur: PropTypes.func, - onScroll: PropTypes.func, - value: PropTypes.string, - defaultValue: PropTypes.string, - onLoad: PropTypes.func, - onSelectionChange: PropTypes.func, - onCursorChange: PropTypes.func, - onBeforeLoad: PropTypes.func, - onValidate: PropTypes.func, - minLines: PropTypes.number, - maxLines: PropTypes.number, - readOnly: PropTypes.bool, - highlightActiveLine: PropTypes.bool, - tabSize: PropTypes.number, - showPrintMargin: PropTypes.bool, - cursorStart: PropTypes.number, - debounceChangePeriod: PropTypes.number, - editorProps: PropTypes.object, - setOptions: PropTypes.object, - style: PropTypes.object, - scrollMargin: PropTypes.array, - annotations: PropTypes.array, - markers: PropTypes.array, - keyboardHandler: PropTypes.string, - wrapEnabled: PropTypes.bool, - enableSnippets: PropTypes.bool, - enableBasicAutocompletion: PropTypes.oneOfType([ - PropTypes.bool, - PropTypes.array - ]), - enableLiveAutocompletion: PropTypes.oneOfType([ - PropTypes.bool, - PropTypes.array - ]), - navigateToFileEnd: PropTypes.bool, - commands: PropTypes.array, - placeholder: PropTypes.string - }; - ReactAce.defaultProps = { - name: "ace-editor", - focus: false, - mode: "", - theme: "", - height: "500px", - width: "500px", - fontSize: 12, - enableSnippets: false, - showGutter: true, - onChange: null, - onPaste: null, - onLoad: null, - onScroll: null, - minLines: null, - maxLines: null, - readOnly: false, - highlightActiveLine: true, - showPrintMargin: true, - tabSize: 4, - cursorStart: 1, - editorProps: {}, - style: {}, - scrollMargin: [0, 0, 0, 0], - setOptions: {}, - wrapEnabled: false, - enableBasicAutocompletion: false, - enableLiveAutocompletion: false, - placeholder: null, - navigateToFileEnd: true - }; - return ReactAce; -}(React.Component)); -exports["default"] = ReactAce; -//# sourceMappingURL=ace.js.map - -/***/ }), - -/***/ 3532: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -var __extends = (this && this.__extends) || (function () { - var extendStatics = function (d, b) { - extendStatics = Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || - function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; - return extendStatics(d, b); - }; - return function (d, b) { - if (typeof b !== "function" && b !== null) - throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); - extendStatics(d, b); - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); - }; -})(); -Object.defineProperty(exports, "__esModule", ({ value: true })); -var PropTypes = __webpack_require__(5697); -var React = __webpack_require__(7294); -var split_1 = __webpack_require__(8663); -var DiffMatchPatch = __webpack_require__(2027); -var DiffComponent = /** @class */ (function (_super) { - __extends(DiffComponent, _super); - function DiffComponent(props) { - var _this = _super.call(this, props) || this; - _this.state = { - value: _this.props.value - }; - _this.onChange = _this.onChange.bind(_this); - _this.diff = _this.diff.bind(_this); - return _this; - } - DiffComponent.prototype.componentDidUpdate = function () { - var value = this.props.value; - if (value !== this.state.value) { - this.setState({ value: value }); - } - }; - DiffComponent.prototype.onChange = function (value) { - this.setState({ - value: value - }); - if (this.props.onChange) { - this.props.onChange(value); - } - }; - DiffComponent.prototype.diff = function () { - var dmp = new DiffMatchPatch(); - var lhString = this.state.value[0]; - var rhString = this.state.value[1]; - if (lhString.length === 0 && rhString.length === 0) { - return []; - } - var diff = dmp.diff_main(lhString, rhString); - dmp.diff_cleanupSemantic(diff); - var diffedLines = this.generateDiffedLines(diff); - var codeEditorSettings = this.setCodeMarkers(diffedLines); - return codeEditorSettings; - }; - DiffComponent.prototype.generateDiffedLines = function (diff) { - var C = { - DIFF_EQUAL: 0, - DIFF_DELETE: -1, - DIFF_INSERT: 1 - }; - var diffedLines = { - left: [], - right: [] - }; - var cursor = { - left: 1, - right: 1 - }; - diff.forEach(function (chunk) { - var chunkType = chunk[0]; - var text = chunk[1]; - var lines = text.split("\n").length - 1; - // diff-match-patch sometimes returns empty strings at random - if (text.length === 0) { - return; - } - var firstChar = text[0]; - var lastChar = text[text.length - 1]; - var linesToHighlight = 0; - switch (chunkType) { - case C.DIFF_EQUAL: - cursor.left += lines; - cursor.right += lines; - break; - case C.DIFF_DELETE: - // If the deletion starts with a newline, push the cursor down to that line - if (firstChar === "\n") { - cursor.left++; - lines--; - } - linesToHighlight = lines; - // If the deletion does not include a newline, highlight the same line on the right - if (linesToHighlight === 0) { - diffedLines.right.push({ - startLine: cursor.right, - endLine: cursor.right - }); - } - // If the last character is a newline, we don't want to highlight that line - if (lastChar === "\n") { - linesToHighlight -= 1; - } - diffedLines.left.push({ - startLine: cursor.left, - endLine: cursor.left + linesToHighlight - }); - cursor.left += lines; - break; - case C.DIFF_INSERT: - // If the insertion starts with a newline, push the cursor down to that line - if (firstChar === "\n") { - cursor.right++; - lines--; - } - linesToHighlight = lines; - // If the insertion does not include a newline, highlight the same line on the left - if (linesToHighlight === 0) { - diffedLines.left.push({ - startLine: cursor.left, - endLine: cursor.left - }); - } - // If the last character is a newline, we don't want to highlight that line - if (lastChar === "\n") { - linesToHighlight -= 1; - } - diffedLines.right.push({ - startLine: cursor.right, - endLine: cursor.right + linesToHighlight - }); - cursor.right += lines; - break; - default: - throw new Error("Diff type was not defined."); - } - }); - return diffedLines; - }; - // Receives a collection of line numbers and iterates through them to highlight appropriately - // Returns an object that tells the render() method how to display the code editors - DiffComponent.prototype.setCodeMarkers = function (diffedLines) { - if (diffedLines === void 0) { diffedLines = { left: [], right: [] }; } - var codeEditorSettings = []; - var newMarkerSet = { - left: [], - right: [] - }; - for (var i = 0; i < diffedLines.left.length; i++) { - var markerObj = { - startRow: diffedLines.left[i].startLine - 1, - endRow: diffedLines.left[i].endLine, - type: "text", - className: "codeMarker" - }; - newMarkerSet.left.push(markerObj); - } - for (var i = 0; i < diffedLines.right.length; i++) { - var markerObj = { - startRow: diffedLines.right[i].startLine - 1, - endRow: diffedLines.right[i].endLine, - type: "text", - className: "codeMarker" - }; - newMarkerSet.right.push(markerObj); - } - codeEditorSettings[0] = newMarkerSet.left; - codeEditorSettings[1] = newMarkerSet.right; - return codeEditorSettings; - }; - DiffComponent.prototype.render = function () { - var markers = this.diff(); - return (React.createElement(split_1.default, { name: this.props.name, className: this.props.className, focus: this.props.focus, orientation: this.props.orientation, splits: this.props.splits, mode: this.props.mode, theme: this.props.theme, height: this.props.height, width: this.props.width, fontSize: this.props.fontSize, showGutter: this.props.showGutter, onChange: this.onChange, onPaste: this.props.onPaste, onLoad: this.props.onLoad, onScroll: this.props.onScroll, minLines: this.props.minLines, maxLines: this.props.maxLines, readOnly: this.props.readOnly, highlightActiveLine: this.props.highlightActiveLine, showPrintMargin: this.props.showPrintMargin, tabSize: this.props.tabSize, cursorStart: this.props.cursorStart, editorProps: this.props.editorProps, style: this.props.style, scrollMargin: this.props.scrollMargin, setOptions: this.props.setOptions, wrapEnabled: this.props.wrapEnabled, enableBasicAutocompletion: this.props.enableBasicAutocompletion, enableLiveAutocompletion: this.props.enableLiveAutocompletion, value: this.state.value, markers: markers })); - }; - DiffComponent.propTypes = { - cursorStart: PropTypes.number, - editorProps: PropTypes.object, - enableBasicAutocompletion: PropTypes.bool, - enableLiveAutocompletion: PropTypes.bool, - focus: PropTypes.bool, - fontSize: PropTypes.number, - height: PropTypes.string, - highlightActiveLine: PropTypes.bool, - maxLines: PropTypes.number, - minLines: PropTypes.number, - mode: PropTypes.string, - name: PropTypes.string, - className: PropTypes.string, - onLoad: PropTypes.func, - onPaste: PropTypes.func, - onScroll: PropTypes.func, - onChange: PropTypes.func, - orientation: PropTypes.string, - readOnly: PropTypes.bool, - scrollMargin: PropTypes.array, - setOptions: PropTypes.object, - showGutter: PropTypes.bool, - showPrintMargin: PropTypes.bool, - splits: PropTypes.number, - style: PropTypes.object, - tabSize: PropTypes.number, - theme: PropTypes.string, - value: PropTypes.array, - width: PropTypes.string, - wrapEnabled: PropTypes.bool - }; - DiffComponent.defaultProps = { - cursorStart: 1, - editorProps: {}, - enableBasicAutocompletion: false, - enableLiveAutocompletion: false, - focus: false, - fontSize: 12, - height: "500px", - highlightActiveLine: true, - maxLines: null, - minLines: null, - mode: "", - name: "ace-editor", - onLoad: null, - onScroll: null, - onPaste: null, - onChange: null, - orientation: "beside", - readOnly: false, - scrollMargin: [0, 0, 0, 0], - setOptions: {}, - showGutter: true, - showPrintMargin: true, - splits: 2, - style: {}, - tabSize: 4, - theme: "github", - value: ["", ""], - width: "500px", - wrapEnabled: true - }; - return DiffComponent; -}(React.Component)); -exports["default"] = DiffComponent; -//# sourceMappingURL=diff.js.map - -/***/ }), - -/***/ 1048: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.getAceInstance = exports.debounce = exports.editorEvents = exports.editorOptions = void 0; -var editorOptions = [ - "minLines", - "maxLines", - "readOnly", - "highlightActiveLine", - "tabSize", - "enableBasicAutocompletion", - "enableLiveAutocompletion", - "enableSnippets" -]; -exports.editorOptions = editorOptions; -var editorEvents = [ - "onChange", - "onFocus", - "onInput", - "onBlur", - "onCopy", - "onPaste", - "onSelectionChange", - "onCursorChange", - "onScroll", - "handleOptions", - "updateRef" -]; -exports.editorEvents = editorEvents; -var getAceInstance = function () { - var ace; - if (typeof window === "undefined") { - // ace-builds just needs some window object to attach ace to. - // During SSR even just an empty object will work. - __webpack_require__.g.window = {}; - ace = __webpack_require__(3239); - // And it can be discarded immediately afterward to avoid confusing - // other libraries that might detect SSR the same way we did. - delete __webpack_require__.g.window; - } - else if (window.ace) { - // Fallback for ace.require when vanilla ACE is hosted over a CDN - ace = window.ace; - ace.acequire = window.ace.require || window.ace.acequire; - } - else { - ace = __webpack_require__(3239); - } - return ace; -}; -exports.getAceInstance = getAceInstance; -var debounce = function (fn, delay) { - var timer = null; - // tslint:disable-next-line - return function () { - var context = this; - var args = arguments; - clearTimeout(timer); - timer = setTimeout(function () { - fn.apply(context, args); - }, delay); - }; -}; -exports.debounce = debounce; -//# sourceMappingURL=editorOptions.js.map - -/***/ }), - -/***/ 4981: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ value: true })); -exports.diff = exports.split = void 0; -var ace_1 = __webpack_require__(3946); -var diff_1 = __webpack_require__(3532); -exports.diff = diff_1.default; -var split_1 = __webpack_require__(8663); -exports.split = split_1.default; -exports["default"] = ace_1.default; -//# sourceMappingURL=index.js.map - -/***/ }), - -/***/ 8663: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -var __extends = (this && this.__extends) || (function () { - var extendStatics = function (d, b) { - extendStatics = Object.setPrototypeOf || - ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || - function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; - return extendStatics(d, b); - }; - return function (d, b) { - if (typeof b !== "function" && b !== null) - throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); - extendStatics(d, b); - function __() { this.constructor = d; } - d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); - }; -})(); -var __assign = (this && this.__assign) || function () { - __assign = Object.assign || function(t) { - for (var s, i = 1, n = arguments.length; i < n; i++) { - s = arguments[i]; - for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) - t[p] = s[p]; - } - return t; - }; - return __assign.apply(this, arguments); -}; -Object.defineProperty(exports, "__esModule", ({ value: true })); -var editorOptions_1 = __webpack_require__(1048); -var ace = (0, editorOptions_1.getAceInstance)(); -var ace_builds_1 = __webpack_require__(3239); -var ext_split_1 = __webpack_require__(3083); -var PropTypes = __webpack_require__(5697); -var React = __webpack_require__(7294); -var isEqual = __webpack_require__(2307); -var get = __webpack_require__(9208); -var SplitComponent = /** @class */ (function (_super) { - __extends(SplitComponent, _super); - function SplitComponent(props) { - var _this = _super.call(this, props) || this; - editorOptions_1.editorEvents.forEach(function (method) { - _this[method] = _this[method].bind(_this); - }); - _this.debounce = editorOptions_1.debounce; - return _this; - } - SplitComponent.prototype.isInShadow = function (node) { - var parent = node && node.parentNode; - while (parent) { - if (parent.toString() === "[object ShadowRoot]") { - return true; - } - parent = parent.parentNode; - } - return false; - }; - SplitComponent.prototype.componentDidMount = function () { - var _this = this; - var _a = this.props, className = _a.className, onBeforeLoad = _a.onBeforeLoad, mode = _a.mode, focus = _a.focus, theme = _a.theme, fontSize = _a.fontSize, value = _a.value, defaultValue = _a.defaultValue, cursorStart = _a.cursorStart, showGutter = _a.showGutter, wrapEnabled = _a.wrapEnabled, showPrintMargin = _a.showPrintMargin, _b = _a.scrollMargin, scrollMargin = _b === void 0 ? [0, 0, 0, 0] : _b, keyboardHandler = _a.keyboardHandler, onLoad = _a.onLoad, commands = _a.commands, annotations = _a.annotations, markers = _a.markers, splits = _a.splits; - this.editor = ace.edit(this.refEditor); - if (this.isInShadow(this.refEditor)) { - this.editor.renderer.attachToShadowRoot(); - } - this.editor.setTheme("ace/theme/" + theme); - if (onBeforeLoad) { - onBeforeLoad(ace); - } - var editorProps = Object.keys(this.props.editorProps); - var split = new ext_split_1.Split(this.editor.container, "ace/theme/" + theme, splits); - this.editor.env.split = split; - this.splitEditor = split.getEditor(0); - this.split = split; - // in a split scenario we don't want a print margin for the entire application - this.editor.setShowPrintMargin(false); - this.editor.renderer.setShowGutter(false); - // get a list of possible options to avoid 'misspelled option errors' - var availableOptions = this.splitEditor.$options; - if (this.props.debounceChangePeriod) { - this.onChange = this.debounce(this.onChange, this.props.debounceChangePeriod); - } - split.forEach(function (editor, index) { - for (var i = 0; i < editorProps.length; i++) { - editor[editorProps[i]] = _this.props.editorProps[editorProps[i]]; - } - var defaultValueForEditor = get(defaultValue, index); - var valueForEditor = get(value, index, ""); - editor.session.setUndoManager(new ace.UndoManager()); - editor.setTheme("ace/theme/" + theme); - editor.renderer.setScrollMargin(scrollMargin[0], scrollMargin[1], scrollMargin[2], scrollMargin[3]); - editor.getSession().setMode("ace/mode/" + mode); - editor.setFontSize(fontSize); - editor.renderer.setShowGutter(showGutter); - editor.getSession().setUseWrapMode(wrapEnabled); - editor.setShowPrintMargin(showPrintMargin); - editor.on("focus", _this.onFocus); - editor.on("blur", _this.onBlur); - editor.on("input", _this.onInput); - editor.on("copy", _this.onCopy); - editor.on("paste", _this.onPaste); - editor.on("change", _this.onChange); - editor - .getSession() - .selection.on("changeSelection", _this.onSelectionChange); - editor.getSession().selection.on("changeCursor", _this.onCursorChange); - editor.session.on("changeScrollTop", _this.onScroll); - editor.setValue(defaultValueForEditor === undefined - ? valueForEditor - : defaultValueForEditor, cursorStart); - var newAnnotations = get(annotations, index, []); - var newMarkers = get(markers, index, []); - editor.getSession().setAnnotations(newAnnotations); - if (newMarkers && newMarkers.length > 0) { - _this.handleMarkers(newMarkers, editor); - } - for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { - var option = editorOptions_1.editorOptions[i]; - if (availableOptions.hasOwnProperty(option)) { - editor.setOption(option, _this.props[option]); - } - else if (_this.props[option]) { - console.warn("ReaceAce: editor option " + option + " was activated but not found. Did you need to import a related tool or did you possibly mispell the option?"); - } - } - _this.handleOptions(_this.props, editor); - if (Array.isArray(commands)) { - commands.forEach(function (command) { - if (typeof command.exec === "string") { - editor.commands.bindKey(command.bindKey, command.exec); - } - else { - editor.commands.addCommand(command); - } - }); - } - if (keyboardHandler) { - editor.setKeyboardHandler("ace/keyboard/" + keyboardHandler); - } - }); - if (className) { - this.refEditor.className += " " + className; - } - if (focus) { - this.splitEditor.focus(); - } - var sp = this.editor.env.split; - sp.setOrientation(this.props.orientation === "below" ? sp.BELOW : sp.BESIDE); - sp.resize(true); - if (onLoad) { - onLoad(sp); - } - }; - SplitComponent.prototype.componentDidUpdate = function (prevProps) { - var _this = this; - var oldProps = prevProps; - var nextProps = this.props; - var split = this.editor.env.split; - if (nextProps.splits !== oldProps.splits) { - split.setSplits(nextProps.splits); - } - if (nextProps.orientation !== oldProps.orientation) { - split.setOrientation(nextProps.orientation === "below" ? split.BELOW : split.BESIDE); - } - split.forEach(function (editor, index) { - if (nextProps.mode !== oldProps.mode) { - editor.getSession().setMode("ace/mode/" + nextProps.mode); - } - if (nextProps.keyboardHandler !== oldProps.keyboardHandler) { - if (nextProps.keyboardHandler) { - editor.setKeyboardHandler("ace/keyboard/" + nextProps.keyboardHandler); - } - else { - editor.setKeyboardHandler(null); - } - } - if (nextProps.fontSize !== oldProps.fontSize) { - editor.setFontSize(nextProps.fontSize); - } - if (nextProps.wrapEnabled !== oldProps.wrapEnabled) { - editor.getSession().setUseWrapMode(nextProps.wrapEnabled); - } - if (nextProps.showPrintMargin !== oldProps.showPrintMargin) { - editor.setShowPrintMargin(nextProps.showPrintMargin); - } - if (nextProps.showGutter !== oldProps.showGutter) { - editor.renderer.setShowGutter(nextProps.showGutter); - } - for (var i = 0; i < editorOptions_1.editorOptions.length; i++) { - var option = editorOptions_1.editorOptions[i]; - if (nextProps[option] !== oldProps[option]) { - editor.setOption(option, nextProps[option]); - } - } - if (!isEqual(nextProps.setOptions, oldProps.setOptions)) { - _this.handleOptions(nextProps, editor); - } - var nextValue = get(nextProps.value, index, ""); - if (editor.getValue() !== nextValue) { - // editor.setValue is a synchronous function call, change event is emitted before setValue return. - _this.silent = true; - var pos = editor.session.selection.toJSON(); - editor.setValue(nextValue, nextProps.cursorStart); - editor.session.selection.fromJSON(pos); - _this.silent = false; - } - var newAnnotations = get(nextProps.annotations, index, []); - var oldAnnotations = get(oldProps.annotations, index, []); - if (!isEqual(newAnnotations, oldAnnotations)) { - editor.getSession().setAnnotations(newAnnotations); - } - var newMarkers = get(nextProps.markers, index, []); - var oldMarkers = get(oldProps.markers, index, []); - if (!isEqual(newMarkers, oldMarkers) && Array.isArray(newMarkers)) { - _this.handleMarkers(newMarkers, editor); - } - }); - if (nextProps.className !== oldProps.className) { - var appliedClasses = this.refEditor.className; - var appliedClassesArray_1 = appliedClasses.trim().split(" "); - var oldClassesArray = oldProps.className.trim().split(" "); - oldClassesArray.forEach(function (oldClass) { - var index = appliedClassesArray_1.indexOf(oldClass); - appliedClassesArray_1.splice(index, 1); - }); - this.refEditor.className = - " " + nextProps.className + " " + appliedClassesArray_1.join(" "); - } - if (nextProps.theme !== oldProps.theme) { - split.setTheme("ace/theme/" + nextProps.theme); - } - if (nextProps.focus && !oldProps.focus) { - this.splitEditor.focus(); - } - if (nextProps.height !== this.props.height || - nextProps.width !== this.props.width) { - this.editor.resize(); - } - }; - SplitComponent.prototype.componentWillUnmount = function () { - this.editor.destroy(); - this.editor = null; - }; - SplitComponent.prototype.onChange = function (event) { - if (this.props.onChange && !this.silent) { - var value_1 = []; - this.editor.env.split.forEach(function (editor) { - value_1.push(editor.getValue()); - }); - this.props.onChange(value_1, event); - } - }; - SplitComponent.prototype.onSelectionChange = function (event) { - if (this.props.onSelectionChange) { - var value_2 = []; - this.editor.env.split.forEach(function (editor) { - value_2.push(editor.getSelection()); - }); - this.props.onSelectionChange(value_2, event); - } - }; - SplitComponent.prototype.onCursorChange = function (event) { - if (this.props.onCursorChange) { - var value_3 = []; - this.editor.env.split.forEach(function (editor) { - value_3.push(editor.getSelection()); - }); - this.props.onCursorChange(value_3, event); - } - }; - SplitComponent.prototype.onFocus = function (event) { - if (this.props.onFocus) { - this.props.onFocus(event); - } - }; - SplitComponent.prototype.onInput = function (event) { - if (this.props.onInput) { - this.props.onInput(event); - } - }; - SplitComponent.prototype.onBlur = function (event) { - if (this.props.onBlur) { - this.props.onBlur(event); - } - }; - SplitComponent.prototype.onCopy = function (text) { - if (this.props.onCopy) { - this.props.onCopy(text); - } - }; - SplitComponent.prototype.onPaste = function (text) { - if (this.props.onPaste) { - this.props.onPaste(text); - } - }; - SplitComponent.prototype.onScroll = function () { - if (this.props.onScroll) { - this.props.onScroll(this.editor); - } - }; - SplitComponent.prototype.handleOptions = function (props, editor) { - var setOptions = Object.keys(props.setOptions); - for (var y = 0; y < setOptions.length; y++) { - editor.setOption(setOptions[y], props.setOptions[setOptions[y]]); - } - }; - SplitComponent.prototype.handleMarkers = function (markers, editor) { - // remove foreground markers - var currentMarkers = editor.getSession().getMarkers(true); - for (var i in currentMarkers) { - if (currentMarkers.hasOwnProperty(i)) { - editor.getSession().removeMarker(currentMarkers[i].id); - } - } - // remove background markers - currentMarkers = editor.getSession().getMarkers(false); - for (var i in currentMarkers) { - if (currentMarkers.hasOwnProperty(i)) { - editor.getSession().removeMarker(currentMarkers[i].id); - } - } - // add new markers - markers.forEach(function (_a) { - var startRow = _a.startRow, startCol = _a.startCol, endRow = _a.endRow, endCol = _a.endCol, className = _a.className, type = _a.type, _b = _a.inFront, inFront = _b === void 0 ? false : _b; - var range = new ace_builds_1.Range(startRow, startCol, endRow, endCol); - editor - .getSession() - .addMarker(range, className, type, inFront); - }); - }; - SplitComponent.prototype.updateRef = function (item) { - this.refEditor = item; - }; - SplitComponent.prototype.render = function () { - var _a = this.props, name = _a.name, width = _a.width, height = _a.height, style = _a.style; - var divStyle = __assign({ width: width, height: height }, style); - return React.createElement("div", { ref: this.updateRef, id: name, style: divStyle }); - }; - SplitComponent.propTypes = { - className: PropTypes.string, - debounceChangePeriod: PropTypes.number, - defaultValue: PropTypes.arrayOf(PropTypes.string), - focus: PropTypes.bool, - fontSize: PropTypes.oneOfType([PropTypes.number, PropTypes.string]), - height: PropTypes.string, - mode: PropTypes.string, - name: PropTypes.string, - onBlur: PropTypes.func, - onChange: PropTypes.func, - onCopy: PropTypes.func, - onFocus: PropTypes.func, - onInput: PropTypes.func, - onLoad: PropTypes.func, - onPaste: PropTypes.func, - onScroll: PropTypes.func, - orientation: PropTypes.string, - showGutter: PropTypes.bool, - splits: PropTypes.number, - theme: PropTypes.string, - value: PropTypes.arrayOf(PropTypes.string), - width: PropTypes.string, - onSelectionChange: PropTypes.func, - onCursorChange: PropTypes.func, - onBeforeLoad: PropTypes.func, - minLines: PropTypes.number, - maxLines: PropTypes.number, - readOnly: PropTypes.bool, - highlightActiveLine: PropTypes.bool, - tabSize: PropTypes.number, - showPrintMargin: PropTypes.bool, - cursorStart: PropTypes.number, - editorProps: PropTypes.object, - setOptions: PropTypes.object, - style: PropTypes.object, - scrollMargin: PropTypes.array, - annotations: PropTypes.array, - markers: PropTypes.array, - keyboardHandler: PropTypes.string, - wrapEnabled: PropTypes.bool, - enableBasicAutocompletion: PropTypes.oneOfType([ - PropTypes.bool, - PropTypes.array - ]), - enableLiveAutocompletion: PropTypes.oneOfType([ - PropTypes.bool, - PropTypes.array - ]), - commands: PropTypes.array - }; - SplitComponent.defaultProps = { - name: "ace-editor", - focus: false, - orientation: "beside", - splits: 2, - mode: "", - theme: "", - height: "500px", - width: "500px", - value: [], - fontSize: 12, - showGutter: true, - onChange: null, - onPaste: null, - onLoad: null, - onScroll: null, - minLines: null, - maxLines: null, - readOnly: false, - highlightActiveLine: true, - showPrintMargin: true, - tabSize: 4, - cursorStart: 1, - editorProps: {}, - style: {}, - scrollMargin: [0, 0, 0, 0], - setOptions: {}, - wrapEnabled: false, - enableBasicAutocompletion: false, - enableLiveAutocompletion: false - }; - return SplitComponent; -}(React.Component)); -exports["default"] = SplitComponent; -//# sourceMappingURL=split.js.map - -/***/ }) - -}]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug deleted file mode 100644 index a99349924c1a..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/analysis-snapshot.rust-debug +++ /dev/null @@ -1,4344 +0,0 @@ -TestSnapshot { - vars: [ - ( - ( - Atom('App' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('App' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Boolean' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Component' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Component' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Constructor' type=dynamic), - #5, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Constructor' type=dynamic), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Derived' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('NewTarget' type=dynamic), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Object' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 10, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 10, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Promise' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Proxy' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ReferenceError' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Reflect' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Super' type=inline), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Symbol' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('TypeError' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_Component' type=dynamic), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_N_E' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exec__' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exports__' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_appGetInitialProps' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_assertThisInitialized' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_asyncToGenerator' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_callee' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_callee$' type=dynamic), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_classCallCheck' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_createClass' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_createSuper' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_createSuperInternal' type=dynamic), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_ctx' type=inline), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_defineProperties' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_getPrototypeOf' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_getPrototypeOf' type=dynamic), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_inherits' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_interopRequireDefault' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_interopRequireDefault1' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_isNativeReflectConstruct' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_next' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_next' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_possibleConstructorReturn' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_props' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_react' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_runtimeJs' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_setPrototypeOf' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_setPrototypeOf' type=dynamic), - #14, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_super' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_throw' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_throw' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_typeof' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_utils' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('appGetInitialProps' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arg' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('args' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arguments' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('asyncGeneratorStep' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('call' type=static), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ctx' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('descriptor' type=dynamic), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('err' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('error' type=inline), - #22, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('fn' type=inline), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('gen' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('gen' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('get' type=static), - #19, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('get' type=static), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('hasNativeReflectConstruct' type=dynamic), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('info' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('instance' type=dynamic), - #5, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleId' type=dynamic), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('o' type=inline), - #8, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('o' type=inline), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('o' type=inline), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('o' type=inline), - #14, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #11, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('p' type=inline), - #14, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pageProps' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pageProps' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('param' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('protoProps' type=dynamic), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reject' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reject' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('render' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolve' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolve' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('result' type=inline), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: false, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('staticProps' type=dynamic), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('subClass' type=dynamic), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('superClass' type=dynamic), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 5, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('target' type=static), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('undefined' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('window' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ], -} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js deleted file mode 100644 index 935b6707472c..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_app-6982cbb7db4140a2/input.js +++ /dev/null @@ -1,226 +0,0 @@ -(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[888],{ - -/***/ 915: -/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { - - - (window.__NEXT_P = window.__NEXT_P || []).push([ - "/_app", - function () { - return __webpack_require__(4297); - } - ]); - if(false) {} - - -/***/ }), - -/***/ 4297: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -var _runtimeJs = _interopRequireDefault(__webpack_require__(4051)); -function _assertThisInitialized(self) { - if (self === void 0) { - throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); - } - return self; -} -function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); - } -} -function _defineProperties(target, props) { - for(var i = 0; i < props.length; i++){ - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } -} -function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; -} -function _getPrototypeOf(o) { - _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { - return o.__proto__ || Object.getPrototypeOf(o); - }; - return _getPrototypeOf(o); -} -function _inherits(subClass, superClass) { - if (typeof superClass !== "function" && superClass !== null) { - throw new TypeError("Super expression must either be null or a function"); - } - subClass.prototype = Object.create(superClass && superClass.prototype, { - constructor: { - value: subClass, - writable: true, - configurable: true - } - }); - if (superClass) _setPrototypeOf(subClass, superClass); -} -function _interopRequireDefault(obj) { - return obj && obj.__esModule ? obj : { - default: obj - }; -} -function _possibleConstructorReturn(self, call) { - if (call && (_typeof(call) === "object" || typeof call === "function")) { - return call; - } - return _assertThisInitialized(self); -} -function _setPrototypeOf(o, p) { - _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { - o.__proto__ = p; - return o; - }; - return _setPrototypeOf(o, p); -} -var _typeof = function(obj) { - "@swc/helpers - typeof"; - return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj; -}; -function _isNativeReflectConstruct() { - if (typeof Reflect === "undefined" || !Reflect.construct) return false; - if (Reflect.construct.sham) return false; - if (typeof Proxy === "function") return true; - try { - Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {})); - return true; - } catch (e) { - return false; - } -} -function _createSuper(Derived) { - var hasNativeReflectConstruct = _isNativeReflectConstruct(); - return function _createSuperInternal() { - var Super = _getPrototypeOf(Derived), result; - if (hasNativeReflectConstruct) { - var NewTarget = _getPrototypeOf(this).constructor; - result = Reflect.construct(Super, arguments, NewTarget); - } else { - result = Super.apply(this, arguments); - } - return _possibleConstructorReturn(this, result); - }; -} -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -Object.defineProperty(exports, "AppInitialProps", ({ - enumerable: true, - get: function get() { - return _utils.AppInitialProps; - } -})); -Object.defineProperty(exports, "NextWebVitalsMetric", ({ - enumerable: true, - get: function get() { - return _utils.NextWebVitalsMetric; - } -})); -exports["default"] = void 0; -var _react = _interopRequireDefault1(__webpack_require__(7294)); -var _utils = __webpack_require__(670); -function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { - try { - var info = gen[key](arg); - var value = info.value; - } catch (error) { - reject(error); - return; - } - if (info.done) { - resolve(value); - } else { - Promise.resolve(value).then(_next, _throw); - } -} -function _asyncToGenerator(fn) { - return function() { - var self = this, args = arguments; - return new Promise(function(resolve, reject) { - var gen = fn.apply(self, args); - function _next(value) { - asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); - } - function _throw(err) { - asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); - } - _next(undefined); - }); - }; -} -function _interopRequireDefault1(obj) { - return obj && obj.__esModule ? obj : { - default: obj - }; -} -function appGetInitialProps(_) { - return _appGetInitialProps.apply(this, arguments); -} -function _appGetInitialProps() { - _appGetInitialProps = /** - * `App` component is used for initialize of pages. It allows for overwriting and full control of the `page` initialization. - * This allows for keeping state between navigation, custom error handling, injecting additional data. - */ _asyncToGenerator(_runtimeJs.default.mark(function _callee(param) { - var Component, ctx, pageProps; - return _runtimeJs.default.wrap(function _callee$(_ctx) { - while(1)switch(_ctx.prev = _ctx.next){ - case 0: - Component = param.Component, ctx = param.ctx; - _ctx.next = 3; - return (0, _utils).loadGetInitialProps(Component, ctx); - case 3: - pageProps = _ctx.sent; - return _ctx.abrupt("return", { - pageProps: pageProps - }); - case 5: - case "end": - return _ctx.stop(); - } - }, _callee); - })); - return _appGetInitialProps.apply(this, arguments); -} -var App = /*#__PURE__*/ function(_Component) { - _inherits(App, _Component); - var _super = _createSuper(App); - function App() { - _classCallCheck(this, App); - return _super.apply(this, arguments); - } - _createClass(App, [ - { - key: "render", - value: function render() { - var _props = this.props, Component = _props.Component, pageProps = _props.pageProps; - return /*#__PURE__*/ _react.default.createElement(Component, Object.assign({}, pageProps)); - } - } - ]); - return App; -}(_react.default.Component); -exports["default"] = App; -App.origGetInitialProps = appGetInitialProps; -App.getInitialProps = appGetInitialProps; //# sourceMappingURL=_app.js.map - - -/***/ }) - -}, -/******/ function(__webpack_require__) { // webpackRuntimeModules -/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } -/******/ __webpack_require__.O(0, [774,179], function() { return __webpack_exec__(915), __webpack_exec__(880); }); -/******/ var __webpack_exports__ = __webpack_require__.O(); -/******/ _N_E = __webpack_exports__; -/******/ } -]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug deleted file mode 100644 index 12ec67f9931f..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/analysis-snapshot.rust-debug +++ /dev/null @@ -1,388 +0,0 @@ -TestSnapshot { - vars: [ - ( - ( - Atom('_N_E' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exec__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exports__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleId' type=dynamic), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: false, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('window' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ], -} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js deleted file mode 100644 index 448527c7ff3a..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/_error-04f03cfa2a163874/input.js +++ /dev/null @@ -1,25 +0,0 @@ -(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[820],{ - -/***/ 4977: -/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { - - - (window.__NEXT_P = window.__NEXT_P || []).push([ - "/_error", - function () { - return __webpack_require__(67); - } - ]); - if(false) {} - - -/***/ }) - -}, -/******/ function(__webpack_require__) { // webpackRuntimeModules -/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } -/******/ __webpack_require__.O(0, [888,774,179], function() { return __webpack_exec__(4977); }); -/******/ var __webpack_exports__ = __webpack_require__.O(); -/******/ _N_E = __webpack_exports__; -/******/ } -]); \ No newline at end of file diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug deleted file mode 100644 index 31a3e8806bfb..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/analysis-snapshot.rust-debug +++ /dev/null @@ -1,7664 +0,0 @@ -TestSnapshot { - vars: [ - ( - ( - Atom('ALL_INITIALIZERS' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Ace' type=inline), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Array' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Constructor' type=dynamic), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Constructor' type=dynamic), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Error' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Index' type=inline), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LazyImpl' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LazyImpl' type=dynamic), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Loadable' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableComponent' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableContext' type=dynamic), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableImpl' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableImpl' type=dynamic), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableInitializer' type=dynamic), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableSubscription' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('LoadableSubscription' type=dynamic), - #35, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Loading' type=inline), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Object' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 14, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Promise' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('READY_INITIALIZERS' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Set' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('Symbol' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('TypeError' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_N_E' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_exports' type=dynamic), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__unused_webpack_module' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exec__' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exports__' type=dynamic), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_exports__' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #2, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_require__' type=dynamic), - #58, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('__webpack_unused_export__' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_classCallCheck' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_clearTimeouts' type=dynamic), - #42, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_createClass' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_default' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_defineProperties' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_defineProperty' type=static), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_defineProperty' type=static), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_didIteratorError' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_err' type=inline), - #39, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_instanceof' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_interopRequireDefault' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_interopRequireDefault' type=dynamic), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_interopRequireDefault' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_iterator' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_iteratorError' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_iteratorNormalCompletion' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_loadable' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_loadableContext' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_objectSpread' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_objectSpread' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_react' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_react' type=inline), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_react' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_step' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this' type=inline), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this1' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_this2' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_update' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('_useSubscription' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('a' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('a' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('a' type=inline), - #56, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('arguments' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 3, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('b' type=inline), - #55, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('c' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 8, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('callback' type=dynamic), - #41, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('callback' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('clearTimeout' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('context' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('createLoadableComponent' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('d' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('descriptor' type=dynamic), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 7, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 7, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dynamic' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('dynamicOptions' type=dynamic), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 6, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('e' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('err' type=inline), - #26, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('err' type=inline), - #34, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: true, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('error' type=inline), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #13, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('exports' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('f' type=inline), - #53, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 2, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('flushInitializers' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('g' type=inline), - #52, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('getCurrentValue' type=dynamic), - #43, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('h' type=inline), - #54, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('i' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ids' type=inline), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ids' type=inline), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ids' type=inline), - #48, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('init' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('init' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('init' type=inline), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('initialized' type=dynamic), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('initializers' type=dynamic), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('instance' type=dynamic), - #16, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isLoading' type=dynamic), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('isServerSide' type=dynamic), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #8, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #19, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('key' type=static), - #22, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('left' type=inline), - #5, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('load' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loadFn' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loadFn' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loadableFn' type=dynamic), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loadableOptions' type=dynamic), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 18, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 3, - mutation_by_call_count: 6, - usage_count: 15, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loadableOptions' type=dynamic), - #12, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loaded' type=inline), - #25, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('loader' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #51, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('module' type=static), - #57, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleId' type=dynamic), - #33, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleId' type=dynamic), - #59, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleIds' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('moduleName' type=dynamic), - #31, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('next_dynamic__WEBPACK_IMPORTED_MODULE_1__' type=dynamic), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('noSSR' type=inline), - #3, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #11, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #14, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #19, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #23, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('obj' type=inline), - #27, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('options' type=inline), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('options' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opts' type=inline), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 14, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 14, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opts' type=inline), - #36, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opts' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 5, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 5, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('opts' type=inline), - #45, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ownKeys' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ownKeys' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('param' type=inline), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('partial' type=inline), - #40, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('pastDelay' type=dynamic), - #10, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('promise' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('promise' type=inline), - #37, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('promises' type=dynamic), - #46, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('props' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('protoProps' type=dynamic), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__' type=dynamic), - #50, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ref' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ref' type=inline), - #32, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('ref' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('reject' type=inline), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('res' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('res' type=inline), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: true, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolve' type=inline), - #15, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolveInitializers' type=dynamic), - #47, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('resolvePreload' type=dynamic), - #49, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('retry' type=inline), - #38, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('right' type=inline), - #5, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('self' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: false, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('setTimeout' type=dynamic), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: true, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('source' type=inline), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('source' type=inline), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 4, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 3, - usage_count: 4, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('state' type=inline), - #24, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 6, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('state' type=inline), - #30, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 9, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 9, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('staticProps' type=dynamic), - #18, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('sub' type=inline), - #29, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 8, - cond_init: true, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 4, - usage_count: 8, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('subscribe' type=dynamic), - #44, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 0, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: true, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 0, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: false, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: false, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('subscription' type=dynamic), - #28, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 6, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 1, - mutation_by_call_count: 2, - usage_count: 5, - reassigned_with_assignment: true, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('suspenseOptions' type=dynamic), - #9, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: Some( - "var", - ), - var_initialized: true, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('sym' type=inline), - #7, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('sym' type=inline), - #21, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('target' type=static), - #6, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('target' type=static), - #17, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('target' type=static), - #20, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: true, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: true, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('undefined' type=static), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 1, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 1, - usage_count: 1, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #4, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('value' type=inline), - #19, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 2, - cond_init: false, - declared: true, - declared_count: 1, - declared_as_fn_param: true, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 2, - usage_count: 2, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: false, - has_property_mutation: false, - accessed_props: {}, - exported: false, - used_above_decl: false, - is_fn_local: true, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ( - ( - Atom('window' type=inline), - #1, - ), - VarUsageInfo { - inline_prevented: false, - ref_count: 3, - cond_init: false, - declared: false, - declared_count: 0, - declared_as_fn_param: false, - declared_as_fn_expr: false, - assign_count: 0, - mutation_by_call_count: 0, - usage_count: 3, - reassigned_with_assignment: false, - reassigned_with_var_decl: false, - mutated: true, - has_property_access: true, - has_property_mutation: true, - accessed_props: {}, - exported: false, - used_above_decl: true, - is_fn_local: false, - used_by_nested_fn: true, - executed_multiple_time: false, - used_in_cond: true, - var_kind: None, - var_initialized: false, - declared_as_catch_param: false, - no_side_effect_for_member_access: false, - used_as_callee: false, - used_as_arg: false, - pure_fn: false, - infects: [], - }, - ), - ], -} diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js deleted file mode 100644 index b57bd572a854..000000000000 --- a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/pages/index-665b680df96552be/input.js +++ /dev/null @@ -1,588 +0,0 @@ -(self["webpackChunk_N_E"] = self["webpackChunk_N_E"] || []).push([[405],{ - -/***/ 8581: -/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) { - - - (window.__NEXT_P = window.__NEXT_P || []).push([ - "/", - function () { - return __webpack_require__(4369); - } - ]); - if(false) {} - - -/***/ }), - -/***/ 7645: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; -var __webpack_unused_export__; - -function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { - value: value, - enumerable: true, - configurable: true, - writable: true - }); - } else { - obj[key] = value; - } - return obj; -} -function _instanceof(left, right) { - if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { - return !!right[Symbol.hasInstance](left); - } else { - return left instanceof right; - } -} -function _objectSpread(target) { - for(var i = 1; i < arguments.length; i++){ - var source = arguments[i] != null ? arguments[i] : {}; - var ownKeys = Object.keys(source); - if (typeof Object.getOwnPropertySymbols === "function") { - ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { - return Object.getOwnPropertyDescriptor(source, sym).enumerable; - })); - } - ownKeys.forEach(function(key) { - _defineProperty(target, key, source[key]); - }); - } - return target; -} -__webpack_unused_export__ = ({ - value: true -}); -exports["default"] = dynamic; -__webpack_unused_export__ = noSSR; -var _react = _interopRequireDefault(__webpack_require__(7294)); -var _loadable = _interopRequireDefault(__webpack_require__(4588)); -function dynamic(dynamicOptions, options) { - var loadableFn = _loadable.default; - var loadableOptions = { - // A loading component is not required, so we default it - loading: function(param) { - var error = param.error, isLoading = param.isLoading, pastDelay = param.pastDelay; - if (!pastDelay) return null; - if (false) {} - return null; - } - }; - // Support for direct import(), eg: dynamic(import('../hello-world')) - // Note that this is only kept for the edge case where someone is passing in a promise as first argument - // The react-loadable babel plugin will turn dynamic(import('../hello-world')) into dynamic(() => import('../hello-world')) - // To make sure we don't execute the import without rendering first - if (_instanceof(dynamicOptions, Promise)) { - loadableOptions.loader = function() { - return dynamicOptions; - }; - // Support for having import as a function, eg: dynamic(() => import('../hello-world')) - } else if (typeof dynamicOptions === 'function') { - loadableOptions.loader = dynamicOptions; - // Support for having first argument being options, eg: dynamic({loader: import('../hello-world')}) - } else if (typeof dynamicOptions === 'object') { - loadableOptions = _objectSpread({}, loadableOptions, dynamicOptions); - } - // Support for passing options, eg: dynamic(import('../hello-world'), {loading: () =>

Loading something

}) - loadableOptions = _objectSpread({}, loadableOptions, options); - var suspenseOptions = loadableOptions; - // Error if Fizz rendering is not enabled and `suspense` option is set to true - if ( true && suspenseOptions.suspense) { - throw new Error("Invalid suspense option usage in next/dynamic. Read more: https://nextjs.org/docs/messages/invalid-dynamic-suspense"); - } - if (suspenseOptions.suspense) { - return loadableFn(suspenseOptions); - } - // coming from build/babel/plugins/react-loadable-plugin.js - if (loadableOptions.loadableGenerated) { - loadableOptions = _objectSpread({}, loadableOptions, loadableOptions.loadableGenerated); - delete loadableOptions.loadableGenerated; - } - // support for disabling server side rendering, eg: dynamic(import('../hello-world'), {ssr: false}) - if (typeof loadableOptions.ssr === 'boolean') { - if (!loadableOptions.ssr) { - delete loadableOptions.ssr; - return noSSR(loadableFn, loadableOptions); - } - delete loadableOptions.ssr; - } - return loadableFn(loadableOptions); -} -function _interopRequireDefault(obj) { - return obj && obj.__esModule ? obj : { - default: obj - }; -} -var isServerSide = "object" === 'undefined'; -function noSSR(LoadableInitializer, loadableOptions) { - // Removing webpack and modules means react-loadable won't try preloading - delete loadableOptions.webpack; - delete loadableOptions.modules; - // This check is necessary to prevent react-loadable from initializing on the server - if (!isServerSide) { - return LoadableInitializer(loadableOptions); - } - var Loading = loadableOptions.loading; - // This will only be rendered on the server side - return function() { - return /*#__PURE__*/ _react.default.createElement(Loading, { - error: null, - isLoading: true, - pastDelay: false, - timedOut: false - }); - }; -} //# sourceMappingURL=dynamic.js.map - - -/***/ }), - -/***/ 3644: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports.LoadableContext = void 0; -var _react = _interopRequireDefault(__webpack_require__(7294)); -function _interopRequireDefault(obj) { - return obj && obj.__esModule ? obj : { - default: obj - }; -} -var LoadableContext = _react.default.createContext(null); -exports.LoadableContext = LoadableContext; -if (false) {} //# sourceMappingURL=loadable-context.js.map - - -/***/ }), - -/***/ 4588: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; - -function _classCallCheck(instance, Constructor) { - if (!(instance instanceof Constructor)) { - throw new TypeError("Cannot call a class as a function"); - } -} -function _defineProperties(target, props) { - for(var i = 0; i < props.length; i++){ - var descriptor = props[i]; - descriptor.enumerable = descriptor.enumerable || false; - descriptor.configurable = true; - if ("value" in descriptor) descriptor.writable = true; - Object.defineProperty(target, descriptor.key, descriptor); - } -} -function _createClass(Constructor, protoProps, staticProps) { - if (protoProps) _defineProperties(Constructor.prototype, protoProps); - if (staticProps) _defineProperties(Constructor, staticProps); - return Constructor; -} -function _defineProperty(obj, key, value) { - if (key in obj) { - Object.defineProperty(obj, key, { - value: value, - enumerable: true, - configurable: true, - writable: true - }); - } else { - obj[key] = value; - } - return obj; -} -function _objectSpread(target) { - for(var i = 1; i < arguments.length; i++){ - var source = arguments[i] != null ? arguments[i] : {}; - var ownKeys = Object.keys(source); - if (typeof Object.getOwnPropertySymbols === "function") { - ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) { - return Object.getOwnPropertyDescriptor(source, sym).enumerable; - })); - } - ownKeys.forEach(function(key) { - _defineProperty(target, key, source[key]); - }); - } - return target; -} -Object.defineProperty(exports, "__esModule", ({ - value: true -})); -exports["default"] = void 0; -var _react = _interopRequireDefault(__webpack_require__(7294)); -var _useSubscription = __webpack_require__(7161); -var _loadableContext = __webpack_require__(3644); -function _interopRequireDefault(obj) { - return obj && obj.__esModule ? obj : { - default: obj - }; -} -var ALL_INITIALIZERS = []; -var READY_INITIALIZERS = []; -var initialized = false; -function load(loader) { - var promise = loader(); - var state = { - loading: true, - loaded: null, - error: null - }; - state.promise = promise.then(function(loaded) { - state.loading = false; - state.loaded = loaded; - return loaded; - }).catch(function(err) { - state.loading = false; - state.error = err; - throw err; - }); - return state; -} -function resolve(obj) { - return obj && obj.__esModule ? obj.default : obj; -} -function createLoadableComponent(loadFn, options) { - var init = function init() { - if (!subscription) { - var sub = new LoadableSubscription(loadFn, opts); - subscription = { - getCurrentValue: sub.getCurrentValue.bind(sub), - subscribe: sub.subscribe.bind(sub), - retry: sub.retry.bind(sub), - promise: sub.promise.bind(sub) - }; - } - return subscription.promise(); - }; - var LoadableImpl = function LoadableImpl(props, ref) { - init(); - var context = _react.default.useContext(_loadableContext.LoadableContext); - var state = (0, _useSubscription).useSubscription(subscription); - _react.default.useImperativeHandle(ref, function() { - return { - retry: subscription.retry - }; - }, []); - if (context && Array.isArray(opts.modules)) { - opts.modules.forEach(function(moduleName) { - context(moduleName); - }); - } - return _react.default.useMemo(function() { - if (state.loading || state.error) { - return _react.default.createElement(opts.loading, { - isLoading: state.loading, - pastDelay: state.pastDelay, - timedOut: state.timedOut, - error: state.error, - retry: subscription.retry - }); - } else if (state.loaded) { - return _react.default.createElement(resolve(state.loaded), props); - } else { - return null; - } - }, [ - props, - state - ]); - }; - var LazyImpl = function LazyImpl(props, ref) { - return _react.default.createElement(opts.lazy, _objectSpread({}, props, { - ref: ref - })); - }; - var opts = Object.assign({ - loader: null, - loading: null, - delay: 200, - timeout: null, - webpack: null, - modules: null, - suspense: false - }, options); - if (opts.suspense) { - opts.lazy = _react.default.lazy(opts.loader); - } - var subscription = null; - // Server only - if (false) {} - // Client only - if (!initialized && "object" !== 'undefined' && !opts.suspense) { - // require.resolveWeak check is needed for environments that don't have it available like Jest - var moduleIds = opts.webpack && "function" === 'function' ? opts.webpack() : opts.modules; - if (moduleIds) { - READY_INITIALIZERS.push(function(ids) { - var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined; - try { - for(var _iterator = moduleIds[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){ - var moduleId = _step.value; - if (ids.indexOf(moduleId) !== -1) { - return init(); - } - } - } catch (err) { - _didIteratorError = true; - _iteratorError = err; - } finally{ - try { - if (!_iteratorNormalCompletion && _iterator.return != null) { - _iterator.return(); - } - } finally{ - if (_didIteratorError) { - throw _iteratorError; - } - } - } - }); - } - } - var LoadableComponent = opts.suspense ? LazyImpl : LoadableImpl; - LoadableComponent.preload = function() { - return !opts.suspense && init(); - }; - LoadableComponent.displayName = 'LoadableComponent'; - return _react.default.forwardRef(LoadableComponent); -} -var LoadableSubscription = /*#__PURE__*/ function() { - function LoadableSubscription(loadFn, opts) { - _classCallCheck(this, LoadableSubscription); - this._loadFn = loadFn; - this._opts = opts; - this._callbacks = new Set(); - this._delay = null; - this._timeout = null; - this.retry(); - } - _createClass(LoadableSubscription, [ - { - key: "promise", - value: function promise() { - return this._res.promise; - } - }, - { - key: "retry", - value: function retry() { - var _this = this; - this._clearTimeouts(); - this._res = this._loadFn(this._opts.loader); - this._state = { - pastDelay: false, - timedOut: false - }; - var ref = this, res = ref._res, opts = ref._opts; - if (res.loading) { - if (typeof opts.delay === 'number') { - if (opts.delay === 0) { - this._state.pastDelay = true; - } else { - var _this1 = this; - this._delay = setTimeout(function() { - _this1._update({ - pastDelay: true - }); - }, opts.delay); - } - } - if (typeof opts.timeout === 'number') { - var _this2 = this; - this._timeout = setTimeout(function() { - _this2._update({ - timedOut: true - }); - }, opts.timeout); - } - } - this._res.promise.then(function() { - _this._update({}); - _this._clearTimeouts(); - }).catch(function(_err) { - _this._update({}); - _this._clearTimeouts(); - }); - this._update({}); - } - }, - { - key: "_update", - value: function _update(partial) { - this._state = _objectSpread({}, this._state, { - error: this._res.error, - loaded: this._res.loaded, - loading: this._res.loading - }, partial); - this._callbacks.forEach(function(callback) { - return callback(); - }); - } - }, - { - key: "_clearTimeouts", - value: function _clearTimeouts() { - clearTimeout(this._delay); - clearTimeout(this._timeout); - } - }, - { - key: "getCurrentValue", - value: function getCurrentValue() { - return this._state; - } - }, - { - key: "subscribe", - value: function subscribe(callback) { - var _this = this; - this._callbacks.add(callback); - return function() { - _this._callbacks.delete(callback); - }; - } - } - ]); - return LoadableSubscription; -}(); -function Loadable(opts) { - return createLoadableComponent(load, opts); -} -function flushInitializers(initializers, ids) { - var promises = []; - while(initializers.length){ - var init = initializers.pop(); - promises.push(init(ids)); - } - return Promise.all(promises).then(function() { - if (initializers.length) { - return flushInitializers(initializers, ids); - } - }); -} -Loadable.preloadAll = function() { - return new Promise(function(resolveInitializers, reject) { - flushInitializers(ALL_INITIALIZERS).then(resolveInitializers, reject); - }); -}; -Loadable.preloadReady = function() { - var ids = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : []; - return new Promise(function(resolvePreload) { - var res = function() { - initialized = true; - return resolvePreload(); - }; - // We always will resolve, errors should be handled within loading UIs. - flushInitializers(READY_INITIALIZERS, ids).then(res, res); - }); -}; -if (true) { - window.__NEXT_PRELOADREADY = Loadable.preloadReady; -} -var _default = Loadable; -exports["default"] = _default; //# sourceMappingURL=loadable.js.map - - -/***/ }), - -/***/ 4369: -/***/ (function(__unused_webpack_module, __webpack_exports__, __webpack_require__) { - -"use strict"; -__webpack_require__.r(__webpack_exports__); -/* harmony export */ __webpack_require__.d(__webpack_exports__, { -/* harmony export */ "default": function() { return /* binding */ Index; } -/* harmony export */ }); -/* harmony import */ var react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(5893); -/* harmony import */ var next_dynamic__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(5152); - - -var Ace = (0,next_dynamic__WEBPACK_IMPORTED_MODULE_1__["default"])(function() { - return Promise.all(/* import() */[__webpack_require__.e(281), __webpack_require__.e(981)]).then(__webpack_require__.bind(__webpack_require__, 4981)); -}, { - loadableGenerated: { - webpack: function() { - return [ - /*require.resolve*/(4981) - ]; - } - }, - loading: function() { - return /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("div", { - children: "Loading..." - }); - }, - ssr: false -}); -function Index() { - return /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsxs)("main", { - children: [ - /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)("h1", { - children: "Code editor" - }), - /*#__PURE__*/ (0,react_jsx_runtime__WEBPACK_IMPORTED_MODULE_0__.jsx)(Ace, {}) - ] - }); -}; - - -/***/ }), - -/***/ 5152: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -module.exports = __webpack_require__(7645) - - -/***/ }), - -/***/ 8217: -/***/ (function(__unused_webpack_module, exports, __webpack_require__) { - -"use strict"; -/** @license React vundefined - * use-subscription.production.min.js - * - * Copyright (c) Facebook, Inc. and its affiliates. - * - * This source code is licensed under the MIT license found in the - * LICENSE file in the root directory of this source tree. - */ -var e=__webpack_require__(6086),g=__webpack_require__(7294); -exports.useSubscription=function(a){var c=a.getCurrentValue,d=a.subscribe,b=g.useState(function(){return{getCurrentValue:c,subscribe:d,value:c()}});a=b[0];var f=b[1];b=a.value;if(a.getCurrentValue!==c||a.subscribe!==d)b=c(),f({getCurrentValue:c,subscribe:d,value:b});g.useDebugValue(b);g.useEffect(function(){function b(){if(!a){var b=c();f(function(a){return a.getCurrentValue!==c||a.subscribe!==d||a.value===b?a:e({},a,{value:b})})}}var a=!1,h=d(b);b();return function(){a=!0;h()}},[c,d]);return b}; - - -/***/ }), - -/***/ 7161: -/***/ (function(module, __unused_webpack_exports, __webpack_require__) { - -"use strict"; - - -if (true) { - module.exports = __webpack_require__(8217); -} else {} - - -/***/ }) - -}, -/******/ function(__webpack_require__) { // webpackRuntimeModules -/******/ var __webpack_exec__ = function(moduleId) { return __webpack_require__(__webpack_require__.s = moduleId); } -/******/ __webpack_require__.O(0, [774,888,179], function() { return __webpack_exec__(8581); }); -/******/ var __webpack_exports__ = __webpack_require__.O(); -/******/ _N_E = __webpack_exports__; -/******/ } -]); \ No newline at end of file From dd5ca8e9304de03170972e43e5062f3d849d1ca2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 29 Mar 2022 18:51:04 +0900 Subject: [PATCH 4/5] Fix --- crates/swc_ecma_minifier/src/compress/optimize/iife.rs | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/crates/swc_ecma_minifier/src/compress/optimize/iife.rs b/crates/swc_ecma_minifier/src/compress/optimize/iife.rs index 2186c2ef09c4..3f71779de616 100644 --- a/crates/swc_ecma_minifier/src/compress/optimize/iife.rs +++ b/crates/swc_ecma_minifier/src/compress/optimize/iife.rs @@ -4,7 +4,9 @@ use rustc_hash::FxHashMap; use swc_atoms::js_word; use swc_common::{pass::Either, util::take::Take, Spanned, DUMMY_SP}; use swc_ecma_ast::*; -use swc_ecma_utils::{contains_arguments, ident::IdentLike, undefined, ExprFactory, Id}; +use swc_ecma_utils::{ + contains_arguments, contains_this_expr, ident::IdentLike, undefined, ExprFactory, Id, +}; use swc_ecma_visit::VisitMutWith; use super::{util::MultiReplacer, Optimizer}; @@ -586,7 +588,7 @@ where return false; } - if contains_arguments(body) { + if contains_this_expr(body) || contains_arguments(body) { return false; } From f17faa1171c5971e713a44dccf0fd8d70973de37 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Donny/=EA=B0=95=EB=8F=99=EC=9C=A4?= Date: Tue, 29 Mar 2022 18:53:04 +0900 Subject: [PATCH 5/5] Update test refs --- ...edPropertyNames19_ES5_es2015.2.minified.js | 4 +- ...putedPropertyNames19_ES5_es5.2.minified.js | 4 +- ...edPropertyNames19_ES6_es2015.2.minified.js | 4 +- ...putedPropertyNames19_ES6_es5.2.minified.js | 4 +- .../fixture/issues/2257/full/output.js | 4 +- .../fixture/issues/quagga2/1.4.2/1/output.js | 4 +- .../8a28b14e.d8fbda268ed281a1/output.js | 12381 ++++++++++++++++ .../tests/projects/output/mootools-1.4.5.js | 26 +- 8 files changed, 12414 insertions(+), 17 deletions(-) create mode 100644 crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/output.js diff --git a/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es2015.2.minified.js b/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es2015.2.minified.js index ffb3ead1fc97..9ae80039011b 100644 --- a/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es2015.2.minified.js +++ b/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es2015.2.minified.js @@ -1,2 +1,4 @@ var M; -M || (M = {}), this.bar; +!function(M) { + this.bar; +}(M || (M = {})); diff --git a/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es5.2.minified.js b/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es5.2.minified.js index 44fda375deca..392c84b0ebfe 100644 --- a/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es5.2.minified.js +++ b/crates/swc/tests/tsc-references/computedPropertyNames19_ES5_es5.2.minified.js @@ -1,3 +1,5 @@ var M; import * as swcHelpers from "@swc/helpers"; -M || (M = {}), swcHelpers.defineProperty({}, this.bar, 0); +!function(M) { + swcHelpers.defineProperty({}, this.bar, 0); +}(M || (M = {})); diff --git a/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es2015.2.minified.js b/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es2015.2.minified.js index ffb3ead1fc97..9ae80039011b 100644 --- a/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es2015.2.minified.js +++ b/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es2015.2.minified.js @@ -1,2 +1,4 @@ var M; -M || (M = {}), this.bar; +!function(M) { + this.bar; +}(M || (M = {})); diff --git a/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es5.2.minified.js b/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es5.2.minified.js index 44fda375deca..392c84b0ebfe 100644 --- a/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es5.2.minified.js +++ b/crates/swc/tests/tsc-references/computedPropertyNames19_ES6_es5.2.minified.js @@ -1,3 +1,5 @@ var M; import * as swcHelpers from "@swc/helpers"; -M || (M = {}), swcHelpers.defineProperty({}, this.bar, 0); +!function(M) { + swcHelpers.defineProperty({}, this.bar, 0); +}(M || (M = {})); diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/issues/2257/full/output.js b/crates/swc_ecma_minifier/tests/compress/fixture/issues/2257/full/output.js index 10426e998366..db994bf44526 100644 --- a/crates/swc_ecma_minifier/tests/compress/fixture/issues/2257/full/output.js +++ b/crates/swc_ecma_minifier/tests/compress/fixture/issues/2257/full/output.js @@ -3819,7 +3819,9 @@ var check = function(it) { return it && it.Math == Math && it; }; - module.exports = check('object' == typeof globalThis && globalThis) || check('object' == typeof window && window) || check('object' == typeof self && self) || check('object' == typeof __webpack_require__.g && __webpack_require__.g) || this || Function('return this')(); + module.exports = check('object' == typeof globalThis && globalThis) || check('object' == typeof window && window) || check('object' == typeof self && self) || check('object' == typeof __webpack_require__.g && __webpack_require__.g) || function() { + return this; + }() || Function('return this')(); }, 1521: function(module, __unused_webpack_exports, __webpack_require__) { var toObject = __webpack_require__(89343), hasOwnProperty = {}.hasOwnProperty; diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/issues/quagga2/1.4.2/1/output.js b/crates/swc_ecma_minifier/tests/compress/fixture/issues/quagga2/1.4.2/1/output.js index c3fa6dcf9631..c292bc4a2325 100644 --- a/crates/swc_ecma_minifier/tests/compress/fixture/issues/quagga2/1.4.2/1/output.js +++ b/crates/swc_ecma_minifier/tests/compress/fixture/issues/quagga2/1.4.2/1/output.js @@ -1167,7 +1167,9 @@ }, function(module, exports) { var g; - g = this; + g = function() { + return this; + }(); try { g = g || new Function("return this")(); } catch (e) { diff --git a/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/output.js b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/output.js new file mode 100644 index 000000000000..21526ec9ef2d --- /dev/null +++ b/crates/swc_ecma_minifier/tests/compress/fixture/next/react-ace/chunks/8a28b14e.d8fbda268ed281a1/output.js @@ -0,0 +1,12381 @@ +(self.webpackChunk_N_E = self.webpackChunk_N_E || []).push([ + [ + 281 + ], + { + 3239: function(module1, __unused_webpack_exports, __webpack_require__) { + var global1, define, _require, require1, normalizeModule, lookup, ns1, root; + module1 = __webpack_require__.nmd(module1), (global1 = function() { + return this; + }()) || "undefined" == typeof window || (global1 = window), (define = function(module, deps, payload) { + if ("string" != typeof module) { + define.original ? define.original.apply(this, arguments) : (console.error("dropping module because define wasn\'t a string."), console.trace()); + return; + } + 2 == arguments.length && (payload = deps), define.modules[module] || (define.payloads[module] = payload, define.modules[module] = null); + }).modules = {}, define.payloads = {}, _require = function(parentId, module, callback) { + if ("string" == typeof module) { + var payload = lookup(parentId, module); + if (void 0 != payload) return callback && callback(), payload; + } else if ("[object Array]" === Object.prototype.toString.call(module)) { + for(var params = [], i = 0, l = module.length; i < l; ++i){ + var dep = lookup(parentId, module[i]); + if (void 0 == dep && require1.original) return; + params.push(dep); + } + return callback && callback.apply(null, params) || !0; + } + }, require1 = function(module, callback) { + var packagedModule = _require("", module, callback); + return void 0 == packagedModule && require1.original ? require1.original.apply(this, arguments) : packagedModule; + }, normalizeModule = function(parentId, moduleName) { + if (-1 !== moduleName.indexOf("!")) { + var chunks = moduleName.split("!"); + return normalizeModule(parentId, chunks[0]) + "!" + normalizeModule(parentId, chunks[1]); + } + if ("." == moduleName.charAt(0)) for(moduleName = parentId.split("/").slice(0, -1).join("/") + "/" + moduleName; -1 !== moduleName.indexOf(".") && previous != moduleName;){ + var previous = moduleName; + moduleName = moduleName.replace(/\/\.\//, "/").replace(/[^\/]+\/\.\.\//, ""); + } + return moduleName; + }, lookup = function(parentId, moduleName) { + moduleName = normalizeModule(parentId, moduleName); + var module2 = define.modules[moduleName]; + if (!module2) { + if ('function' == typeof (module2 = define.payloads[moduleName])) { + var exports = {}, mod = { + id: moduleName, + uri: '', + exports: exports, + packaged: !0 + }; + exports = module2(function(module, callback) { + return _require(moduleName, module, callback); + }, exports, mod) || mod.exports, define.modules[moduleName] = exports, delete define.payloads[moduleName]; + } + module2 = define.modules[moduleName] = exports || module2; + } + return module2; + }, ns1 = "ace", root = global1, ns1 && (global1[ns1] || (global1[ns1] = {}), root = global1[ns1]), root.define && root.define.packaged || (define.original = root.define, root.define = define, root.define.packaged = !0), root.require && root.require.packaged || (require1.original = root.require, root.require = require1, root.require.packaged = !0), ace.define("ace/lib/fixoldbrowsers", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + "undefined" == typeof Element || Element.prototype.remove || Object.defineProperty(Element.prototype, "remove", { + enumerable: !1, + writable: !0, + configurable: !0, + value: function() { + this.parentNode && this.parentNode.removeChild(this); + } + }); + }), ace.define("ace/lib/useragent", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + exports.OS = { + LINUX: "LINUX", + MAC: "MAC", + WINDOWS: "WINDOWS" + }, exports.getOS = function() { + return exports.isMac ? exports.OS.MAC : exports.isLinux ? exports.OS.LINUX : exports.OS.WINDOWS; + }; + var _navigator = "object" == typeof navigator ? navigator : {}, os = (/mac|win|linux/i.exec(_navigator.platform) || [ + "other" + ])[0].toLowerCase(), ua = _navigator.userAgent || "", appName = _navigator.appName || ""; + exports.isWin = "win" == os, exports.isMac = "mac" == os, exports.isLinux = "linux" == os, exports.isIE = "Microsoft Internet Explorer" == appName || appName.indexOf("MSAppHost") >= 0 ? parseFloat((ua.match(/(?:MSIE |Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/) || [])[1]) : parseFloat((ua.match(/(?:Trident\/[0-9]+[\.0-9]+;.*rv:)([0-9]+[\.0-9]+)/) || [])[1]), exports.isOldIE = exports.isIE && exports.isIE < 9, exports.isGecko = exports.isMozilla = ua.match(/ Gecko\/\d+/), exports.isOpera = "object" == typeof opera && "[object Opera]" == Object.prototype.toString.call(window.opera), exports.isWebKit = parseFloat(ua.split("WebKit/")[1]) || void 0, exports.isChrome = parseFloat(ua.split(" Chrome/")[1]) || void 0, exports.isEdge = parseFloat(ua.split(" Edge/")[1]) || void 0, exports.isAIR = ua.indexOf("AdobeAIR") >= 0, exports.isAndroid = ua.indexOf("Android") >= 0, exports.isChromeOS = ua.indexOf(" CrOS ") >= 0, exports.isIOS = /iPad|iPhone|iPod/.test(ua) && !window.MSStream, exports.isIOS && (exports.isMac = !0), exports.isMobile = exports.isIOS || exports.isAndroid; + }), ace.define("ace/lib/dom", [ + "require", + "exports", + "module", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var strictCSP, useragent = require("./useragent"); + exports.buildDom = function buildDom(arr, parent, refs) { + if ("string" == typeof arr && arr) { + var txt = document.createTextNode(arr); + return parent && parent.appendChild(txt), txt; + } + if (!Array.isArray(arr)) return arr && arr.appendChild && parent && parent.appendChild(arr), arr; + if ("string" != typeof arr[0] || !arr[0]) { + for(var els = [], i = 0; i < arr.length; i++){ + var ch = buildDom(arr[i], parent, refs); + ch && els.push(ch); + } + return els; + } + var el = document.createElement(arr[0]), options = arr[1], childIndex = 1; + options && "object" == typeof options && !Array.isArray(options) && (childIndex = 2); + for(var i = childIndex; i < arr.length; i++)buildDom(arr[i], el, refs); + return 2 == childIndex && Object.keys(options).forEach(function(n) { + var val = options[n]; + "class" === n ? el.className = Array.isArray(val) ? val.join(" ") : val : "function" == typeof val || "value" == n || "$" == n[0] ? el[n] = val : "ref" === n ? refs && (refs[val] = el) : "style" === n ? "string" == typeof val && (el.style.cssText = val) : null != val && el.setAttribute(n, val); + }), parent && parent.appendChild(el), el; + }, exports.getDocumentHead = function(doc) { + return doc || (doc = document), doc.head || doc.getElementsByTagName("head")[0] || doc.documentElement; + }, exports.createElement = function(tag, ns) { + return document.createElementNS ? document.createElementNS(ns || "http://www.w3.org/1999/xhtml", tag) : document.createElement(tag); + }, exports.removeChildren = function(element) { + element.innerHTML = ""; + }, exports.createTextNode = function(textContent, element) { + return (element ? element.ownerDocument : document).createTextNode(textContent); + }, exports.createFragment = function(element) { + return (element ? element.ownerDocument : document).createDocumentFragment(); + }, exports.hasCssClass = function(el, name) { + return -1 !== (el.className + "").split(/\s+/g).indexOf(name); + }, exports.addCssClass = function(el, name) { + exports.hasCssClass(el, name) || (el.className += " " + name); + }, exports.removeCssClass = function(el, name) { + for(var classes = el.className.split(/\s+/g);;){ + var index = classes.indexOf(name); + if (-1 == index) break; + classes.splice(index, 1); + } + el.className = classes.join(" "); + }, exports.toggleCssClass = function(el, name) { + for(var classes = el.className.split(/\s+/g), add = !0;;){ + var index = classes.indexOf(name); + if (-1 == index) break; + add = !1, classes.splice(index, 1); + } + return add && classes.push(name), el.className = classes.join(" "), add; + }, exports.setCssClass = function(node, className, include) { + include ? exports.addCssClass(node, className) : exports.removeCssClass(node, className); + }, exports.hasCssString = function(id, doc) { + var sheets, index = 0; + if (sheets = (doc = doc || document).querySelectorAll("style")) { + for(; index < sheets.length;)if (sheets[index++].id === id) return !0; + } + }; + var cssCache = []; + function insertPendingStyles() { + var cache = cssCache; + cssCache = null, cache && cache.forEach(function(item) { + importCssString(item[0], item[1]); + }); + } + function importCssString(cssText, id, target) { + if ("undefined" != typeof document) { + if (cssCache) { + if (target) insertPendingStyles(); + else if (!1 === target) return cssCache.push([ + cssText, + id + ]); + } + if (!strictCSP) { + var container = target; + target && target.getRootNode ? (container = target.getRootNode()) && container != target || (container = document) : container = document; + var doc = container.ownerDocument || container; + if (id && exports.hasCssString(id, container)) return null; + id && (cssText += "\n/*# sourceURL=ace/css/" + id + " */"); + var style = exports.createElement("style"); + style.appendChild(doc.createTextNode(cssText)), id && (style.id = id), container == doc && (container = exports.getDocumentHead(doc)), container.insertBefore(style, container.firstChild); + } + } + } + if (exports.useStrictCSP = function(value) { + strictCSP = value, !1 == value ? insertPendingStyles() : cssCache || (cssCache = []); + }, exports.importCssString = importCssString, exports.importCssStylsheet = function(uri, doc) { + exports.buildDom([ + "link", + { + rel: "stylesheet", + href: uri + } + ], exports.getDocumentHead(doc)); + }, exports.scrollbarWidth = function(document) { + var inner = exports.createElement("ace_inner"); + inner.style.width = "100%", inner.style.minWidth = "0px", inner.style.height = "200px", inner.style.display = "block"; + var outer = exports.createElement("ace_outer"), style = outer.style; + style.position = "absolute", style.left = "-10000px", style.overflow = "hidden", style.width = "200px", style.minWidth = "0px", style.height = "150px", style.display = "block", outer.appendChild(inner); + var body = document.documentElement; + body.appendChild(outer); + var noScrollbar = inner.offsetWidth; + style.overflow = "scroll"; + var withScrollbar = inner.offsetWidth; + return noScrollbar == withScrollbar && (withScrollbar = outer.clientWidth), body.removeChild(outer), noScrollbar - withScrollbar; + }, exports.computedStyle = function(element, style) { + return window.getComputedStyle(element, "") || {}; + }, exports.setStyle = function(styles, property, value) { + styles[property] !== value && (styles[property] = value); + }, exports.HAS_CSS_ANIMATION = !1, exports.HAS_CSS_TRANSFORMS = !1, exports.HI_DPI = !useragent.isWin || "undefined" != typeof window && window.devicePixelRatio >= 1.5, useragent.isChromeOS && (exports.HI_DPI = !1), "undefined" != typeof document) { + var div = document.createElement("div"); + exports.HI_DPI && void 0 !== div.style.transform && (exports.HAS_CSS_TRANSFORMS = !0), useragent.isEdge || void 0 === div.style.animationName || (exports.HAS_CSS_ANIMATION = !0), div = null; + } + exports.HAS_CSS_TRANSFORMS ? exports.translate = function(element, tx, ty) { + element.style.transform = "translate(" + Math.round(tx) + "px, " + Math.round(ty) + "px)"; + } : exports.translate = function(element, tx, ty) { + element.style.top = Math.round(ty) + "px", element.style.left = Math.round(tx) + "px"; + }; + }), ace.define("ace/lib/oop", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + exports.inherits = function(ctor, superCtor) { + ctor.super_ = superCtor, ctor.prototype = Object.create(superCtor.prototype, { + constructor: { + value: ctor, + enumerable: !1, + writable: !0, + configurable: !0 + } + }); + }, exports.mixin = function(obj, mixin) { + for(var key in mixin)obj[key] = mixin[key]; + return obj; + }, exports.implement = function(proto, mixin) { + exports.mixin(proto, mixin); + }; + }), ace.define("ace/lib/keys", [ + "require", + "exports", + "module", + "ace/lib/oop" + ], function(require, exports, module) { + "use strict"; + var oop = require("./oop"), Keys = function() { + var name, i1, ret = { + MODIFIER_KEYS: { + 16: 'Shift', + 17: 'Ctrl', + 18: 'Alt', + 224: 'Meta', + 91: 'MetaLeft', + 92: 'MetaRight', + 93: 'ContextMenu' + }, + KEY_MODS: { + ctrl: 1, + alt: 2, + option: 2, + shift: 4, + "super": 8, + meta: 8, + command: 8, + cmd: 8, + control: 1 + }, + FUNCTION_KEYS: { + 8: "Backspace", + 9: "Tab", + 13: "Return", + 19: "Pause", + 27: "Esc", + 32: "Space", + 33: "PageUp", + 34: "PageDown", + 35: "End", + 36: "Home", + 37: "Left", + 38: "Up", + 39: "Right", + 40: "Down", + 44: "Print", + 45: "Insert", + 46: "Delete", + 96: "Numpad0", + 97: "Numpad1", + 98: "Numpad2", + 99: "Numpad3", + 100: "Numpad4", + 101: "Numpad5", + 102: "Numpad6", + 103: "Numpad7", + 104: "Numpad8", + 105: "Numpad9", + '-13': "NumpadEnter", + 112: "F1", + 113: "F2", + 114: "F3", + 115: "F4", + 116: "F5", + 117: "F6", + 118: "F7", + 119: "F8", + 120: "F9", + 121: "F10", + 122: "F11", + 123: "F12", + 144: "Numlock", + 145: "Scrolllock" + }, + PRINTABLE_KEYS: { + 32: ' ', + 48: '0', + 49: '1', + 50: '2', + 51: '3', + 52: '4', + 53: '5', + 54: '6', + 55: '7', + 56: '8', + 57: '9', + 59: ';', + 61: '=', + 65: 'a', + 66: 'b', + 67: 'c', + 68: 'd', + 69: 'e', + 70: 'f', + 71: 'g', + 72: 'h', + 73: 'i', + 74: 'j', + 75: 'k', + 76: 'l', + 77: 'm', + 78: 'n', + 79: 'o', + 80: 'p', + 81: 'q', + 82: 'r', + 83: 's', + 84: 't', + 85: 'u', + 86: 'v', + 87: 'w', + 88: 'x', + 89: 'y', + 90: 'z', + 107: '+', + 109: '-', + 110: '.', + 186: ';', + 187: '=', + 188: ',', + 189: '-', + 190: '.', + 191: '/', + 192: '`', + 219: '[', + 220: '\\', + 221: ']', + 222: "'", + 111: '/', + 106: '*' + } + }; + for(i1 in ret.FUNCTION_KEYS)name = ret.FUNCTION_KEYS[i1].toLowerCase(), ret[name] = parseInt(i1, 10); + for(i1 in ret.PRINTABLE_KEYS)name = ret.PRINTABLE_KEYS[i1].toLowerCase(), ret[name] = parseInt(i1, 10); + return oop.mixin(ret, ret.MODIFIER_KEYS), oop.mixin(ret, ret.PRINTABLE_KEYS), oop.mixin(ret, ret.FUNCTION_KEYS), ret.enter = ret.return, ret.escape = ret.esc, ret.del = ret.delete, ret[173] = '-', function() { + for(var mods = [ + "cmd", + "ctrl", + "alt", + "shift" + ], i = Math.pow(2, mods.length); i--;)ret.KEY_MODS[i] = mods.filter(function(x) { + return i & ret.KEY_MODS[x]; + }).join("-") + "-"; + }(), ret.KEY_MODS[0] = "", ret.KEY_MODS[-1] = "input-", ret; + }(); + oop.mixin(exports, Keys), exports.keyCodeToString = function(keyCode) { + var keyString = Keys[keyCode]; + return "string" != typeof keyString && (keyString = String.fromCharCode(keyCode)), keyString.toLowerCase(); + }; + }), ace.define("ace/lib/event", [ + "require", + "exports", + "module", + "ace/lib/keys", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var activeListenerOptions, keys = require("./keys"), useragent = require("./useragent"), pressedKeys = null, ts = 0; + function getListenerOptions() { + return void 0 == activeListenerOptions && function() { + activeListenerOptions = !1; + try { + document.createComment("").addEventListener("test", function() {}, { + get passive () { + activeListenerOptions = { + passive: !1 + }; + } + }); + } catch (e) {} + }(), activeListenerOptions; + } + function EventListener(elem, type, callback) { + this.elem = elem, this.type = type, this.callback = callback; + } + EventListener.prototype.destroy = function() { + removeListener(this.elem, this.type, this.callback), this.elem = this.type = this.callback = void 0; + }; + var addListener = exports.addListener = function(elem, type, callback, destroyer) { + elem.addEventListener(type, callback, getListenerOptions()), destroyer && destroyer.$toDestroy.push(new EventListener(elem, type, callback)); + }, removeListener = exports.removeListener = function(elem, type, callback) { + elem.removeEventListener(type, callback, getListenerOptions()); + }; + exports.stopEvent = function(e) { + return exports.stopPropagation(e), exports.preventDefault(e), !1; + }, exports.stopPropagation = function(e) { + e.stopPropagation && e.stopPropagation(); + }, exports.preventDefault = function(e) { + e.preventDefault && e.preventDefault(); + }, exports.getButton = function(e) { + return "dblclick" == e.type ? 0 : "contextmenu" == e.type || useragent.isMac && e.ctrlKey && !e.altKey && !e.shiftKey ? 2 : e.button; + }, exports.capture = function(el, eventHandler, releaseCaptureHandler) { + var ownerDocument = el && el.ownerDocument || document; + function onMouseUp(e) { + eventHandler && eventHandler(e), releaseCaptureHandler && releaseCaptureHandler(e), removeListener(ownerDocument, "mousemove", eventHandler), removeListener(ownerDocument, "mouseup", onMouseUp), removeListener(ownerDocument, "dragstart", onMouseUp); + } + return addListener(ownerDocument, "mousemove", eventHandler), addListener(ownerDocument, "mouseup", onMouseUp), addListener(ownerDocument, "dragstart", onMouseUp), onMouseUp; + }, exports.addMouseWheelListener = function(el, callback, destroyer) { + "onmousewheel" in el ? addListener(el, "mousewheel", function(e) { + var factor = 8; + void 0 !== e.wheelDeltaX ? (e.wheelX = -e.wheelDeltaX / factor, e.wheelY = -e.wheelDeltaY / factor) : (e.wheelX = 0, e.wheelY = -e.wheelDelta / factor), callback(e); + }, destroyer) : "onwheel" in el ? addListener(el, "wheel", function(e) { + var factor = 0.35; + switch(e.deltaMode){ + case e.DOM_DELTA_PIXEL: + e.wheelX = e.deltaX * factor || 0, e.wheelY = e.deltaY * factor || 0; + break; + case e.DOM_DELTA_LINE: + case e.DOM_DELTA_PAGE: + e.wheelX = 5 * (e.deltaX || 0), e.wheelY = 5 * (e.deltaY || 0); + break; + } + callback(e); + }, destroyer) : addListener(el, "DOMMouseScroll", function(e) { + e.axis && e.axis == e.HORIZONTAL_AXIS ? (e.wheelX = 5 * (e.detail || 0), e.wheelY = 0) : (e.wheelX = 0, e.wheelY = 5 * (e.detail || 0)), callback(e); + }, destroyer); + }, exports.addMultiMouseDownListener = function(elements, timeouts, eventHandler, callbackName, destroyer) { + var startX, startY, timer, clicks = 0, eventNames = { + 2: "dblclick", + 3: "tripleclick", + 4: "quadclick" + }; + function onMousedown(e) { + if (0 !== exports.getButton(e) ? clicks = 0 : e.detail > 1 ? (clicks++, clicks > 4 && (clicks = 1)) : clicks = 1, useragent.isIE) { + var isNewClick = Math.abs(e.clientX - startX) > 5 || Math.abs(e.clientY - startY) > 5; + (!timer || isNewClick) && (clicks = 1), timer && clearTimeout(timer), timer = setTimeout(function() { + timer = null; + }, timeouts[clicks - 1] || 600), 1 == clicks && (startX = e.clientX, startY = e.clientY); + } + if (e._clicks = clicks, eventHandler[callbackName]("mousedown", e), clicks > 4) clicks = 0; + else if (clicks > 1) return eventHandler[callbackName](eventNames[clicks], e); + } + Array.isArray(elements) || (elements = [ + elements + ]), elements.forEach(function(el) { + addListener(el, "mousedown", onMousedown, destroyer); + }); + }; + var getModifierHash = function(e) { + return 0 | (e.ctrlKey ? 1 : 0) | (e.altKey ? 2 : 0) | (e.shiftKey ? 4 : 0) | (e.metaKey ? 8 : 0); + }; + function normalizeCommandKeys(callback, e, keyCode) { + var hashId = getModifierHash(e); + if (!useragent.isMac && pressedKeys) { + if (e.getModifierState && (e.getModifierState("OS") || e.getModifierState("Win")) && (hashId |= 8), pressedKeys.altGr) { + if ((3 & hashId) == 3) return; + pressedKeys.altGr = 0; + } + if (18 === keyCode || 17 === keyCode) { + var location = "location" in e ? e.location : e.keyLocation; + 17 === keyCode && 1 === location ? 1 == pressedKeys[keyCode] && (ts = e.timeStamp) : 18 === keyCode && 3 === hashId && 2 === location && e.timeStamp - ts < 50 && (pressedKeys.altGr = !0); + } + } + if (keyCode in keys.MODIFIER_KEYS && (keyCode = -1), !hashId && 13 === keyCode) { + var location = "location" in e ? e.location : e.keyLocation; + if (3 === location && (callback(e, hashId, -keyCode), e.defaultPrevented)) return; + } + if (useragent.isChromeOS && 8 & hashId) { + if (callback(e, hashId, keyCode), e.defaultPrevented) return; + hashId &= -9; + } + return (!!hashId || keyCode in keys.FUNCTION_KEYS || keyCode in keys.PRINTABLE_KEYS) && callback(e, hashId, keyCode); + } + function resetPressedKeys() { + pressedKeys = Object.create(null); + } + if (exports.getModifierString = function(e) { + return keys.KEY_MODS[getModifierHash(e)]; + }, exports.addCommandKeyListener = function(el, callback, destroyer) { + if (!useragent.isOldGecko && (!useragent.isOpera || "KeyboardEvent" in window)) { + var lastDefaultPrevented = null; + addListener(el, "keydown", function(e) { + pressedKeys[e.keyCode] = (pressedKeys[e.keyCode] || 0) + 1; + var result = normalizeCommandKeys(callback, e, e.keyCode); + return lastDefaultPrevented = e.defaultPrevented, result; + }, destroyer), addListener(el, "keypress", function(e) { + lastDefaultPrevented && (e.ctrlKey || e.altKey || e.shiftKey || e.metaKey) && (exports.stopEvent(e), lastDefaultPrevented = null); + }, destroyer), addListener(el, "keyup", function(e) { + pressedKeys[e.keyCode] = null; + }, destroyer), pressedKeys || (resetPressedKeys(), addListener(window, "focus", resetPressedKeys)); + } else { + var lastKeyDownKeyCode = null; + addListener(el, "keydown", function(e) { + lastKeyDownKeyCode = e.keyCode; + }, destroyer), addListener(el, "keypress", function(e) { + return normalizeCommandKeys(callback, e, lastKeyDownKeyCode); + }, destroyer); + } + }, "object" == typeof window && window.postMessage && !useragent.isOldIE) { + var postMessageId = 1; + exports.nextTick = function(callback, win) { + win = win || window; + var messageName = "zero-timeout-message-" + postMessageId++, listener = function(e) { + e.data == messageName && (exports.stopPropagation(e), removeListener(win, "message", listener), callback()); + }; + addListener(win, "message", listener), win.postMessage(messageName, "*"); + }; + } + exports.$idleBlocked = !1, exports.onIdle = function(cb, timeout) { + return setTimeout(function handler() { + exports.$idleBlocked ? setTimeout(handler, 100) : cb(); + }, timeout); + }, exports.$idleBlockId = null, exports.blockIdle = function(delay) { + exports.$idleBlockId && clearTimeout(exports.$idleBlockId), exports.$idleBlocked = !0, exports.$idleBlockId = setTimeout(function() { + exports.$idleBlocked = !1; + }, delay || 100); + }, exports.nextFrame = "object" == typeof window && (window.requestAnimationFrame || window.mozRequestAnimationFrame || window.webkitRequestAnimationFrame || window.msRequestAnimationFrame || window.oRequestAnimationFrame), exports.nextFrame ? exports.nextFrame = exports.nextFrame.bind(window) : exports.nextFrame = function(callback) { + setTimeout(callback, 17); + }; + }), ace.define("ace/range", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + var Range = function(startRow, startColumn, endRow, endColumn) { + this.start = { + row: startRow, + column: startColumn + }, this.end = { + row: endRow, + column: endColumn + }; + }; + (function() { + this.isEqual = function(range) { + return this.start.row === range.start.row && this.end.row === range.end.row && this.start.column === range.start.column && this.end.column === range.end.column; + }, this.toString = function() { + return "Range: [" + this.start.row + "/" + this.start.column + "] -> [" + this.end.row + "/" + this.end.column + "]"; + }, this.contains = function(row, column) { + return 0 == this.compare(row, column); + }, this.compareRange = function(range) { + var cmp, end = range.end, start = range.start; + return 1 == (cmp = this.compare(end.row, end.column)) ? 1 == (cmp = this.compare(start.row, start.column)) ? 2 : 0 == cmp ? 1 : 0 : -1 == cmp ? -2 : -1 == (cmp = this.compare(start.row, start.column)) ? -1 : 1 == cmp ? 42 : 0; + }, this.comparePoint = function(p) { + return this.compare(p.row, p.column); + }, this.containsRange = function(range) { + return 0 == this.comparePoint(range.start) && 0 == this.comparePoint(range.end); + }, this.intersects = function(range) { + var cmp = this.compareRange(range); + return -1 == cmp || 0 == cmp || 1 == cmp; + }, this.isEnd = function(row, column) { + return this.end.row == row && this.end.column == column; + }, this.isStart = function(row, column) { + return this.start.row == row && this.start.column == column; + }, this.setStart = function(row, column) { + "object" == typeof row ? (this.start.column = row.column, this.start.row = row.row) : (this.start.row = row, this.start.column = column); + }, this.setEnd = function(row, column) { + "object" == typeof row ? (this.end.column = row.column, this.end.row = row.row) : (this.end.row = row, this.end.column = column); + }, this.inside = function(row, column) { + return 0 == this.compare(row, column) && !(this.isEnd(row, column) || this.isStart(row, column)); + }, this.insideStart = function(row, column) { + return 0 == this.compare(row, column) && !this.isEnd(row, column); + }, this.insideEnd = function(row, column) { + return 0 == this.compare(row, column) && !this.isStart(row, column); + }, this.compare = function(row, column) { + return this.isMultiLine() || row !== this.start.row ? row < this.start.row ? -1 : row > this.end.row ? 1 : this.start.row === row ? column >= this.start.column ? 0 : -1 : this.end.row === row ? column <= this.end.column ? 0 : 1 : 0 : column < this.start.column ? -1 : column > this.end.column ? 1 : 0; + }, this.compareStart = function(row, column) { + return this.start.row == row && this.start.column == column ? -1 : this.compare(row, column); + }, this.compareEnd = function(row, column) { + return this.end.row == row && this.end.column == column ? 1 : this.compare(row, column); + }, this.compareInside = function(row, column) { + return this.end.row == row && this.end.column == column ? 1 : this.start.row == row && this.start.column == column ? -1 : this.compare(row, column); + }, this.clipRows = function(firstRow, lastRow) { + if (this.end.row > lastRow) var end = { + row: lastRow + 1, + column: 0 + }; + else if (this.end.row < firstRow) var end = { + row: firstRow, + column: 0 + }; + if (this.start.row > lastRow) var start = { + row: lastRow + 1, + column: 0 + }; + else if (this.start.row < firstRow) var start = { + row: firstRow, + column: 0 + }; + return Range.fromPoints(start || this.start, end || this.end); + }, this.extend = function(row, column) { + var cmp = this.compare(row, column); + if (0 == cmp) return this; + if (-1 == cmp) var start = { + row: row, + column: column + }; + else var end = { + row: row, + column: column + }; + return Range.fromPoints(start || this.start, end || this.end); + }, this.isEmpty = function() { + return this.start.row === this.end.row && this.start.column === this.end.column; + }, this.isMultiLine = function() { + return this.start.row !== this.end.row; + }, this.clone = function() { + return Range.fromPoints(this.start, this.end); + }, this.collapseRows = function() { + return 0 == this.end.column ? new Range(this.start.row, 0, Math.max(this.start.row, this.end.row - 1), 0) : new Range(this.start.row, 0, this.end.row, 0); + }, this.toScreenRange = function(session) { + var screenPosStart = session.documentToScreenPosition(this.start), screenPosEnd = session.documentToScreenPosition(this.end); + return new Range(screenPosStart.row, screenPosStart.column, screenPosEnd.row, screenPosEnd.column); + }, this.moveBy = function(row, column) { + this.start.row += row, this.start.column += column, this.end.row += row, this.end.column += column; + }; + }).call(Range.prototype), Range.fromPoints = function(start, end) { + return new Range(start.row, start.column, end.row, end.column); + }, Range.comparePoints = function(p1, p2) { + return p1.row - p2.row || p1.column - p2.column; + }, Range.comparePoints = function(p1, p2) { + return p1.row - p2.row || p1.column - p2.column; + }, exports.Range = Range; + }), ace.define("ace/lib/lang", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + exports.last = function(a) { + return a[a.length - 1]; + }, exports.stringReverse = function(string) { + return string.split("").reverse().join(""); + }, exports.stringRepeat = function(string, count) { + for(var result = ''; count > 0;)1 & count && (result += string), (count >>= 1) && (string += string); + return result; + }; + var trimBeginRegexp = /^\s\s*/, trimEndRegexp = /\s\s*$/; + exports.stringTrimLeft = function(string) { + return string.replace(trimBeginRegexp, ''); + }, exports.stringTrimRight = function(string) { + return string.replace(trimEndRegexp, ''); + }, exports.copyObject = function(obj) { + var copy = {}; + for(var key in obj)copy[key] = obj[key]; + return copy; + }, exports.copyArray = function(array) { + for(var copy = [], i = 0, l = array.length; i < l; i++)array[i] && "object" == typeof array[i] ? copy[i] = this.copyObject(array[i]) : copy[i] = array[i]; + return copy; + }, exports.deepCopy = function deepCopy(obj) { + if ("object" != typeof obj || !obj) return obj; + if (Array.isArray(obj)) { + copy = []; + for(var copy, key = 0; key < obj.length; key++)copy[key] = deepCopy(obj[key]); + return copy; + } + if ("[object Object]" !== Object.prototype.toString.call(obj)) return obj; + for(var key in copy = {}, obj)copy[key] = deepCopy(obj[key]); + return copy; + }, exports.arrayToMap = function(arr) { + for(var map = {}, i = 0; i < arr.length; i++)map[arr[i]] = 1; + return map; + }, exports.createMap = function(props) { + var map = Object.create(null); + for(var i in props)map[i] = props[i]; + return map; + }, exports.arrayRemove = function(array, value) { + for(var i = 0; i <= array.length; i++)value === array[i] && array.splice(i, 1); + }, exports.escapeRegExp = function(str) { + return str.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1'); + }, exports.escapeHTML = function(str) { + return ("" + str).replace(/&/g, "&").replace(/"/g, """).replace(/'/g, "'").replace(/ Date.now() - 50) || ($cancelT = !1); + }, + cancel: function() { + $cancelT = Date.now(); + } + }; + }), ace.define("ace/keyboard/textinput", [ + "require", + "exports", + "module", + "ace/lib/event", + "ace/lib/useragent", + "ace/lib/dom", + "ace/lib/lang", + "ace/clipboard", + "ace/lib/keys" + ], function(require, exports, module) { + "use strict"; + var event = require("../lib/event"), useragent = require("../lib/useragent"), dom = require("../lib/dom"), lang = require("../lib/lang"), clipboard = require("../clipboard"), BROKEN_SETDATA = useragent.isChrome < 18, USE_IE_MIME_TYPE = useragent.isIE, HAS_FOCUS_ARGS = useragent.isChrome > 63, KEYS = require("../lib/keys"), MODS = KEYS.KEY_MODS, isIOS = useragent.isIOS, valueResetRegex = isIOS ? /\s/ : /\n/, isMobile = useragent.isMobile; + exports.TextInput = function(parentNode, host) { + var closeTimeout, text2 = dom.createElement("textarea"); + text2.className = "ace_text-input", text2.setAttribute("wrap", "off"), text2.setAttribute("autocorrect", "off"), text2.setAttribute("autocapitalize", "off"), text2.setAttribute("spellcheck", !1), text2.style.opacity = "0", parentNode.insertBefore(text2, parentNode.firstChild); + var copied = !1, pasted = !1, inComposition = !1, sendingText = !1, tempStyle = ''; + isMobile || (text2.style.fontSize = "1px"); + var commandMode = !1, ignoreFocusEvents = !1, lastValue = "", lastSelectionStart = 0, lastSelectionEnd = 0, lastRestoreEnd = 0; + try { + var isFocused = document.activeElement === text2; + } catch (e1) {} + event.addListener(text2, "blur", function(e) { + ignoreFocusEvents || (host.onBlur(e), isFocused = !1); + }, host), event.addListener(text2, "focus", function(e) { + if (!ignoreFocusEvents) { + if (isFocused = !0, useragent.isEdge) try { + if (!document.hasFocus()) return; + } catch (e2) {} + host.onFocus(e), useragent.isEdge ? setTimeout(resetSelection) : resetSelection(); + } + }, host), this.$focusScroll = !1, this.focus = function() { + if (tempStyle || HAS_FOCUS_ARGS || "browser" == this.$focusScroll) return text2.focus({ + preventScroll: !0 + }); + var top = text2.style.top; + text2.style.position = "fixed", text2.style.top = "0px"; + try { + var isTransformed = 0 != text2.getBoundingClientRect().top; + } catch (e) { + return; + } + var ancestors = []; + if (isTransformed) for(var t = text2.parentElement; t && 1 == t.nodeType;)ancestors.push(t), t.setAttribute("ace_nocontext", !0), t = !t.parentElement && t.getRootNode ? t.getRootNode().host : t.parentElement; + text2.focus({ + preventScroll: !0 + }), isTransformed && ancestors.forEach(function(p) { + p.removeAttribute("ace_nocontext"); + }), setTimeout(function() { + text2.style.position = "", "0px" == text2.style.top && (text2.style.top = top); + }, 0); + }, this.blur = function() { + text2.blur(); + }, this.isFocused = function() { + return isFocused; + }, host.on("beforeEndOperation", function() { + var curOp = host.curOp, commandName = curOp && curOp.command && curOp.command.name; + if ("insertstring" != commandName) { + var isUserAction = commandName && (curOp.docChanged || curOp.selectionChanged); + inComposition && isUserAction && (lastValue = text2.value = "", onCompositionEnd()), resetSelection(); + } + }); + var resetSelection = isIOS ? function(value) { + if (isFocused && (!copied || value) && !sendingText) { + value || (value = ""); + var newValue = "\n ab" + value + "cde fg\n"; + newValue != text2.value && (text2.value = lastValue = newValue); + var selectionStart = 4, selectionEnd = 4 + (value.length || (host.selection.isEmpty() ? 0 : 1)); + (lastSelectionStart != selectionStart || lastSelectionEnd != selectionEnd) && text2.setSelectionRange(selectionStart, selectionEnd), lastSelectionStart = selectionStart, lastSelectionEnd = selectionEnd; + } + } : function() { + if (!inComposition && !sendingText && (isFocused || afterContextMenu)) { + inComposition = !0; + var selectionStart = 0, selectionEnd = 0, line = ""; + if (host.session) { + var selection = host.selection, range = selection.getRange(), row = selection.cursor.row; + if (selectionStart = range.start.column, selectionEnd = range.end.column, line = host.session.getLine(row), range.start.row != row) { + var prevLine = host.session.getLine(row - 1); + selectionStart = range.start.row < row - 1 ? 0 : selectionStart, selectionEnd += prevLine.length + 1, line = prevLine + "\n" + line; + } else if (range.end.row != row) { + var nextLine = host.session.getLine(row + 1); + selectionEnd = range.end.row > row + 1 ? nextLine.length : selectionEnd, selectionEnd += line.length + 1, line = line + "\n" + nextLine; + } else isMobile && row > 0 && (line = "\n" + line, selectionEnd += 1, selectionStart += 1); + line.length > 400 && (selectionStart < 400 && selectionEnd < 400 ? line = line.slice(0, 400) : (line = "\n", selectionStart == selectionEnd ? selectionStart = selectionEnd = 0 : (selectionStart = 0, selectionEnd = 1))); + } + var newValue = line + "\n\n"; + if (newValue != lastValue && (text2.value = lastValue = newValue, lastSelectionStart = lastSelectionEnd = newValue.length), afterContextMenu && (lastSelectionStart = text2.selectionStart, lastSelectionEnd = text2.selectionEnd), lastSelectionEnd != selectionEnd || lastSelectionStart != selectionStart || text2.selectionEnd != lastSelectionEnd) try { + text2.setSelectionRange(selectionStart, selectionEnd), lastSelectionStart = selectionStart, lastSelectionEnd = selectionEnd; + } catch (e) {} + inComposition = !1; + } + }; + this.resetSelection = resetSelection, isFocused && host.onFocus(); + var inputHandler = null; + this.setInputHandler = function(cb) { + inputHandler = cb; + }, this.getInputHandler = function() { + return inputHandler; + }; + var afterContextMenu = !1, sendText = function(value, fromInput) { + if (afterContextMenu && (afterContextMenu = !1), pasted) return resetSelection(), value && host.onPaste(value), pasted = !1, ""; + for(var selectionStart = text2.selectionStart, selectionEnd = text2.selectionEnd, extendLeft = lastSelectionStart, extendRight = lastValue.length - lastSelectionEnd, inserted = value, restoreStart = value.length - selectionStart, restoreEnd = value.length - selectionEnd, i = 0; extendLeft > 0 && lastValue[i] == value[i];)i++, extendLeft--; + for(inserted = inserted.slice(i), i = 1; extendRight > 0 && lastValue.length - i > lastSelectionStart - 1 && lastValue[lastValue.length - i] == value[value.length - i];)i++, extendRight--; + restoreStart -= i - 1, restoreEnd -= i - 1; + var endIndex = inserted.length - i + 1; + if (endIndex < 0 && (extendLeft = -endIndex, endIndex = 0), inserted = inserted.slice(0, endIndex), !fromInput && !inserted && !restoreStart && !extendLeft && !extendRight && !restoreEnd) return ""; + sendingText = !0; + var shouldReset = !1; + return useragent.isAndroid && ". " == inserted && (inserted = " ", shouldReset = !0), (!inserted || extendLeft || extendRight || restoreStart || restoreEnd) && !commandMode ? host.onTextInput(inserted, { + extendLeft: extendLeft, + extendRight: extendRight, + restoreStart: restoreStart, + restoreEnd: restoreEnd + }) : host.onTextInput(inserted), sendingText = !1, lastValue = value, lastSelectionStart = selectionStart, lastSelectionEnd = selectionEnd, lastRestoreEnd = restoreEnd, shouldReset ? "\n" : inserted; + }, onInput = function(e) { + if (inComposition) return onCompositionUpdate(); + if (e && e.inputType) { + if ("historyUndo" == e.inputType) return host.execCommand("undo"); + if ("historyRedo" == e.inputType) return host.execCommand("redo"); + } + var data = text2.value, inserted = sendText(data, !0); + (data.length > 500 || valueResetRegex.test(inserted) || isMobile && lastSelectionStart < 1 && lastSelectionStart == lastSelectionEnd) && resetSelection(); + }, handleClipboardData = function(e, data, forceIEMime) { + var clipboardData = e.clipboardData || window.clipboardData; + if (clipboardData && !BROKEN_SETDATA) { + var mime = USE_IE_MIME_TYPE || forceIEMime ? "Text" : "text/plain"; + try { + if (data) return !1 !== clipboardData.setData(mime, data); + return clipboardData.getData(mime); + } catch (e) { + if (!forceIEMime) return handleClipboardData(e, data, !0); + } + } + }, doCopy = function(e, isCut) { + var data = host.getCopyText(); + if (!data) return event.preventDefault(e); + handleClipboardData(e, data) ? (isIOS && (resetSelection(data), copied = data, setTimeout(function() { + copied = !1; + }, 10)), isCut ? host.onCut() : host.onCopy(), event.preventDefault(e)) : (copied = !0, text2.value = data, text2.select(), setTimeout(function() { + copied = !1, resetSelection(), isCut ? host.onCut() : host.onCopy(); + })); + }, onCut = function(e) { + doCopy(e, !0); + }, onCopy = function(e) { + doCopy(e, !1); + }, onPaste = function(e) { + var data = handleClipboardData(e); + clipboard.pasteCancelled() || ("string" == typeof data ? (data && host.onPaste(data, e), useragent.isIE && setTimeout(resetSelection), event.preventDefault(e)) : (text2.value = "", pasted = !0)); + }; + event.addCommandKeyListener(text2, host.onCommandKey.bind(host), host), event.addListener(text2, "select", function(e) { + if (!inComposition) if (copied) copied = !1; + else { + var text; + 0 === (text = text2).selectionStart && text.selectionEnd >= lastValue.length && text.value === lastValue && lastValue && text.selectionEnd !== lastSelectionEnd ? (host.selectAll(), resetSelection()) : isMobile && text2.selectionStart != lastSelectionStart && resetSelection(); + } + }, host), event.addListener(text2, "input", onInput, host), event.addListener(text2, "cut", onCut, host), event.addListener(text2, "copy", onCopy, host), event.addListener(text2, "paste", onPaste, host), 'oncut' in text2 && 'oncopy' in text2 && 'onpaste' in text2 || event.addListener(parentNode, "keydown", function(e) { + if ((!useragent.isMac || e.metaKey) && e.ctrlKey) switch(e.keyCode){ + case 67: + onCopy(e); + break; + case 86: + onPaste(e); + break; + case 88: + onCut(e); + break; + } + }, host); + var onCompositionUpdate = function() { + if (inComposition && host.onCompositionUpdate && !host.$readOnly) { + if (commandMode) return cancelComposition(); + inComposition.useTextareaForIME ? host.onCompositionUpdate(text2.value) : (sendText(text2.value), inComposition.markerRange && (inComposition.context && (inComposition.markerRange.start.column = inComposition.selectionStart = inComposition.context.compositionStartOffset), inComposition.markerRange.end.column = inComposition.markerRange.start.column + lastSelectionEnd - inComposition.selectionStart + lastRestoreEnd)); + } + }, onCompositionEnd = function(e) { + host.onCompositionEnd && !host.$readOnly && (inComposition = !1, host.onCompositionEnd(), host.off("mousedown", cancelComposition), e && onInput()); + }; + function cancelComposition() { + ignoreFocusEvents = !0, text2.blur(), text2.focus(), ignoreFocusEvents = !1; + } + var syncComposition = lang.delayedCall(onCompositionUpdate, 50).schedule.bind(null, null); + function onContextMenuClose() { + clearTimeout(closeTimeout), closeTimeout = setTimeout(function() { + tempStyle && (text2.style.cssText = tempStyle, tempStyle = ''), host.renderer.$isMousePressed = !1, host.renderer.$keepTextAreaAtCursor && host.renderer.$moveTextAreaToCursor(); + }, 0); + } + event.addListener(text2, "compositionstart", function(e) { + if (!inComposition && host.onCompositionStart && !host.$readOnly && (inComposition = {}, !commandMode)) { + e.data && (inComposition.useTextareaForIME = !1), setTimeout(onCompositionUpdate, 0), host._signal("compositionStart"), host.on("mousedown", cancelComposition); + var range = host.getSelectionRange(); + range.end.row = range.start.row, range.end.column = range.start.column, inComposition.markerRange = range, inComposition.selectionStart = lastSelectionStart, host.onCompositionStart(inComposition), inComposition.useTextareaForIME ? (lastValue = text2.value = "", lastSelectionStart = 0, lastSelectionEnd = 0) : (text2.msGetInputContext && (inComposition.context = text2.msGetInputContext()), text2.getInputContext && (inComposition.context = text2.getInputContext())); + } + }, host), event.addListener(text2, "compositionupdate", onCompositionUpdate, host), event.addListener(text2, "keyup", function(e) { + 27 == e.keyCode && text2.value.length < text2.selectionStart && (inComposition || (lastValue = text2.value), lastSelectionStart = lastSelectionEnd = -1, resetSelection()), syncComposition(); + }, host), event.addListener(text2, "keydown", syncComposition, host), event.addListener(text2, "compositionend", onCompositionEnd, host), this.getElement = function() { + return text2; + }, this.setCommandMode = function(value) { + commandMode = value, text2.readOnly = !1; + }, this.setReadOnly = function(readOnly) { + commandMode || (text2.readOnly = readOnly); + }, this.setCopyWithEmptySelection = function(value) {}, this.onContextMenu = function(e) { + afterContextMenu = !0, resetSelection(), host._emit("nativecontextmenu", { + target: host, + domEvent: e + }), this.moveToMouse(e, !0); + }, this.moveToMouse = function(e3, bringToFront) { + tempStyle || (tempStyle = text2.style.cssText), text2.style.cssText = (bringToFront ? "z-index:100000;" : "") + (useragent.isIE ? "opacity:0.1;" : "") + "text-indent: -" + (lastSelectionStart + lastSelectionEnd) * host.renderer.characterWidth * 0.5 + "px;"; + var rect = host.container.getBoundingClientRect(), style = dom.computedStyle(host.container), top = rect.top + (parseInt(style.borderTopWidth) || 0), left = rect.left + (parseInt(rect.borderLeftWidth) || 0), maxTop = rect.bottom - top - text2.clientHeight - 2, move = function(e) { + dom.translate(text2, e.clientX - left - 2, Math.min(e.clientY - top - 2, maxTop)); + }; + move(e3), "mousedown" == e3.type && (host.renderer.$isMousePressed = !0, clearTimeout(closeTimeout), useragent.isWin && event.capture(host.container, move, onContextMenuClose)); + }, this.onContextMenuClose = onContextMenuClose; + var host1, text1, typingResetTimeout, typing, detectArrowKeys, onContextMenu = function(e) { + host.textInput.onContextMenu(e), onContextMenuClose(); + }; + event.addListener(text2, "mouseup", onContextMenu, host), event.addListener(text2, "mousedown", function(e) { + e.preventDefault(), onContextMenuClose(); + }, host), event.addListener(host.renderer.scroller, "contextmenu", onContextMenu, host), event.addListener(text2, "contextmenu", onContextMenu, host), isIOS && (host1 = host, typingResetTimeout = null, typing = !1, (text1 = text2).addEventListener("keydown", function(e) { + typingResetTimeout && clearTimeout(typingResetTimeout), typing = !0; + }, !0), text1.addEventListener("keyup", function(e) { + typingResetTimeout = setTimeout(function() { + typing = !1; + }, 100); + }, !0), detectArrowKeys = function(e) { + if (document.activeElement === text1 && !typing && !inComposition && !host1.$mouseHandler.isMousePressed && !copied) { + var selectionStart = text1.selectionStart, selectionEnd = text1.selectionEnd, key = null, modifier = 0; + if (0 == selectionStart ? key = KEYS.up : 1 == selectionStart ? key = KEYS.home : selectionEnd > lastSelectionEnd && "\n" == lastValue[selectionEnd] ? key = KEYS.end : selectionStart < lastSelectionStart && " " == lastValue[selectionStart - 1] ? (key = KEYS.left, modifier = MODS.option) : selectionStart < lastSelectionStart || selectionStart == lastSelectionStart && lastSelectionEnd != lastSelectionStart && selectionStart == selectionEnd ? key = KEYS.left : selectionEnd > lastSelectionEnd && lastValue.slice(0, selectionEnd).split("\n").length > 2 ? key = KEYS.down : selectionEnd > lastSelectionEnd && " " == lastValue[selectionEnd - 1] ? (key = KEYS.right, modifier = MODS.option) : (selectionEnd > lastSelectionEnd || selectionEnd == lastSelectionEnd && lastSelectionEnd != lastSelectionStart && selectionStart == selectionEnd) && (key = KEYS.right), selectionStart !== selectionEnd && (modifier |= MODS.shift), key) { + if (!host1.onCommandKey({}, modifier, key) && host1.commands) { + key = KEYS.keyCodeToString(key); + var command = host1.commands.findKeyCommand(modifier, key); + command && host1.execCommand(command); + } + lastSelectionStart = selectionStart, lastSelectionEnd = selectionEnd, resetSelection(""); + } + } + }, document.addEventListener("selectionchange", detectArrowKeys), host1.on("destroy", function() { + document.removeEventListener("selectionchange", detectArrowKeys); + })); + }, exports.$setUserAgentForTests = function(_isMobile, _isIOS) { + isMobile = _isMobile, isIOS = _isIOS; + }; + }), ace.define("ace/mouse/default_handlers", [ + "require", + "exports", + "module", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var useragent = require("../lib/useragent"); + function DefaultHandlers(mouseHandler) { + mouseHandler.$clickSelection = null; + var editor = mouseHandler.editor; + editor.setDefaultHandler("mousedown", this.onMouseDown.bind(mouseHandler)), editor.setDefaultHandler("dblclick", this.onDoubleClick.bind(mouseHandler)), editor.setDefaultHandler("tripleclick", this.onTripleClick.bind(mouseHandler)), editor.setDefaultHandler("quadclick", this.onQuadClick.bind(mouseHandler)), editor.setDefaultHandler("mousewheel", this.onMouseWheel.bind(mouseHandler)), [ + "select", + "startSelect", + "selectEnd", + "selectAllEnd", + "selectByWordsEnd", + "selectByLinesEnd", + "dragWait", + "dragWaitEnd", + "focusWait" + ].forEach(function(x) { + mouseHandler[x] = this[x]; + }, this), mouseHandler.selectByLines = this.extendSelectionBy.bind(mouseHandler, "getLineRange"), mouseHandler.selectByWords = this.extendSelectionBy.bind(mouseHandler, "getWordRange"); + } + function calcRangeOrientation(range, cursor) { + if (range.start.row == range.end.row) var cmp = 2 * cursor.column - range.start.column - range.end.column; + else if (range.start.row != range.end.row - 1 || range.start.column || range.end.column) var cmp = 2 * cursor.row - range.start.row - range.end.row; + else var cmp = cursor.column - 4; + return cmp < 0 ? { + cursor: range.start, + anchor: range.end + } : { + cursor: range.end, + anchor: range.start + }; + } + (function() { + this.onMouseDown = function(ev) { + var inSelection = ev.inSelection(), pos = ev.getDocumentPosition(); + this.mousedownEvent = ev; + var editor = this.editor, button = ev.getButton(); + if (0 !== button) { + (editor.getSelectionRange().isEmpty() || 1 == button) && editor.selection.moveToPosition(pos), 2 != button || (editor.textInput.onContextMenu(ev.domEvent), useragent.isMozilla || ev.preventDefault()); + return; + } + if (this.mousedownEvent.time = Date.now(), inSelection && !editor.isFocused() && (editor.focus(), this.$focusTimeout && !this.$clickSelection && !editor.inMultiSelectMode)) { + this.setState("focusWait"), this.captureMouse(ev); + return; + } + return this.captureMouse(ev), this.startSelect(pos, ev.domEvent._clicks > 1), ev.preventDefault(); + }, this.startSelect = function(pos, waitForClickSelection) { + pos = pos || this.editor.renderer.screenToTextCoordinates(this.x, this.y); + var editor = this.editor; + this.mousedownEvent && (this.mousedownEvent.getShiftKey() ? editor.selection.selectToPosition(pos) : waitForClickSelection || editor.selection.moveToPosition(pos), waitForClickSelection || this.select(), editor.renderer.scroller.setCapture && editor.renderer.scroller.setCapture(), editor.setStyle("ace_selecting"), this.setState("select")); + }, this.select = function() { + var anchor, editor = this.editor, cursor = editor.renderer.screenToTextCoordinates(this.x, this.y); + if (this.$clickSelection) { + var cmp = this.$clickSelection.comparePoint(cursor); + if (-1 == cmp) anchor = this.$clickSelection.end; + else if (1 == cmp) anchor = this.$clickSelection.start; + else { + var orientedRange = calcRangeOrientation(this.$clickSelection, cursor); + cursor = orientedRange.cursor, anchor = orientedRange.anchor; + } + editor.selection.setSelectionAnchor(anchor.row, anchor.column); + } + editor.selection.selectToPosition(cursor), editor.renderer.scrollCursorIntoView(); + }, this.extendSelectionBy = function(unitName) { + var anchor, editor = this.editor, cursor = editor.renderer.screenToTextCoordinates(this.x, this.y), range = editor.selection[unitName](cursor.row, cursor.column); + if (this.$clickSelection) { + var cmpStart = this.$clickSelection.comparePoint(range.start), cmpEnd = this.$clickSelection.comparePoint(range.end); + if (-1 == cmpStart && cmpEnd <= 0) anchor = this.$clickSelection.end, (range.end.row != cursor.row || range.end.column != cursor.column) && (cursor = range.start); + else if (1 == cmpEnd && cmpStart >= 0) anchor = this.$clickSelection.start, (range.start.row != cursor.row || range.start.column != cursor.column) && (cursor = range.end); + else if (-1 == cmpStart && 1 == cmpEnd) cursor = range.end, anchor = range.start; + else { + var orientedRange = calcRangeOrientation(this.$clickSelection, cursor); + cursor = orientedRange.cursor, anchor = orientedRange.anchor; + } + editor.selection.setSelectionAnchor(anchor.row, anchor.column); + } + editor.selection.selectToPosition(cursor), editor.renderer.scrollCursorIntoView(); + }, this.selectEnd = this.selectAllEnd = this.selectByWordsEnd = this.selectByLinesEnd = function() { + this.$clickSelection = null, this.editor.unsetStyle("ace_selecting"), this.editor.renderer.scroller.releaseCapture && this.editor.renderer.scroller.releaseCapture(); + }, this.focusWait = function() { + var ax, ay, distance = (ax = this.mousedownEvent.x, ay = this.mousedownEvent.y, Math.sqrt(Math.pow(this.x - ax, 2) + Math.pow(this.y - ay, 2))), time = Date.now(); + (distance > 0 || time - this.mousedownEvent.time > this.$focusTimeout) && this.startSelect(this.mousedownEvent.getDocumentPosition()); + }, this.onDoubleClick = function(ev) { + var pos = ev.getDocumentPosition(), editor = this.editor, range = editor.session.getBracketRange(pos); + range ? (range.isEmpty() && (range.start.column--, range.end.column++), this.setState("select")) : (range = editor.selection.getWordRange(pos.row, pos.column), this.setState("selectByWords")), this.$clickSelection = range, this.select(); + }, this.onTripleClick = function(ev) { + var pos = ev.getDocumentPosition(), editor = this.editor; + this.setState("selectByLines"); + var range = editor.getSelectionRange(); + range.isMultiLine() && range.contains(pos.row, pos.column) ? (this.$clickSelection = editor.selection.getLineRange(range.start.row), this.$clickSelection.end = editor.selection.getLineRange(range.end.row).end) : this.$clickSelection = editor.selection.getLineRange(pos.row), this.select(); + }, this.onQuadClick = function(ev) { + var editor = this.editor; + editor.selectAll(), this.$clickSelection = editor.getSelectionRange(), this.setState("selectAll"); + }, this.onMouseWheel = function(ev) { + if (!ev.getAccelKey()) { + ev.getShiftKey() && ev.wheelY && !ev.wheelX && (ev.wheelX = ev.wheelY, ev.wheelY = 0); + var editor = this.editor; + this.$lastScroll || (this.$lastScroll = { + t: 0, + vx: 0, + vy: 0, + allowed: 0 + }); + var prevScroll = this.$lastScroll, t = ev.domEvent.timeStamp, dt = t - prevScroll.t, vx = dt ? ev.wheelX / dt : prevScroll.vx, vy = dt ? ev.wheelY / dt : prevScroll.vy; + dt < 550 && (vx = (vx + prevScroll.vx) / 2, vy = (vy + prevScroll.vy) / 2); + var direction = Math.abs(vx / vy), canScroll = !1; + if ((direction >= 1 && editor.renderer.isScrollableBy(ev.wheelX * ev.speed, 0) && (canScroll = !0), direction <= 1 && editor.renderer.isScrollableBy(0, ev.wheelY * ev.speed) && (canScroll = !0), canScroll) ? prevScroll.allowed = t : t - prevScroll.allowed < 550 && (Math.abs(vx) <= 1.5 * Math.abs(prevScroll.vx) && Math.abs(vy) <= 1.5 * Math.abs(prevScroll.vy) ? (canScroll = !0, prevScroll.allowed = t) : prevScroll.allowed = 0), prevScroll.t = t, prevScroll.vx = vx, prevScroll.vy = vy, canScroll) return editor.renderer.scrollBy(ev.wheelX * ev.speed, ev.wheelY * ev.speed), ev.stop(); + } + }; + }).call(DefaultHandlers.prototype), exports.DefaultHandlers = DefaultHandlers; + }), ace.define("ace/tooltip", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + require("./lib/oop"); + var dom = require("./lib/dom"); + function Tooltip(parentNode) { + this.isOpen = !1, this.$element = null, this.$parentNode = parentNode; + } + (function() { + this.$init = function() { + return this.$element = dom.createElement("div"), this.$element.className = "ace_tooltip", this.$element.style.display = "none", this.$parentNode.appendChild(this.$element), this.$element; + }, this.getElement = function() { + return this.$element || this.$init(); + }, this.setText = function(text) { + this.getElement().textContent = text; + }, this.setHtml = function(html) { + this.getElement().innerHTML = html; + }, this.setPosition = function(x, y) { + this.getElement().style.left = x + "px", this.getElement().style.top = y + "px"; + }, this.setClassName = function(className) { + dom.addCssClass(this.getElement(), className); + }, this.show = function(text, x, y) { + null != text && this.setText(text), null != x && null != y && this.setPosition(x, y), this.isOpen || (this.getElement().style.display = "block", this.isOpen = !0); + }, this.hide = function() { + this.isOpen && (this.getElement().style.display = "none", this.isOpen = !1); + }, this.getHeight = function() { + return this.getElement().offsetHeight; + }, this.getWidth = function() { + return this.getElement().offsetWidth; + }, this.destroy = function() { + this.isOpen = !1, this.$element && this.$element.parentNode && this.$element.parentNode.removeChild(this.$element); + }; + }).call(Tooltip.prototype), exports.Tooltip = Tooltip; + }), ace.define("ace/mouse/default_gutter_handler", [ + "require", + "exports", + "module", + "ace/lib/dom", + "ace/lib/oop", + "ace/lib/event", + "ace/tooltip" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"), oop = require("../lib/oop"), event = require("../lib/event"), Tooltip = require("../tooltip").Tooltip; + function GutterTooltip(parentNode) { + Tooltip.call(this, parentNode); + } + oop.inherits(GutterTooltip, Tooltip), (function() { + this.setPosition = function(x, y) { + var windowWidth = window.innerWidth || document.documentElement.clientWidth, windowHeight = window.innerHeight || document.documentElement.clientHeight, width = this.getWidth(), height = this.getHeight(); + y += 15, (x += 15) + width > windowWidth && (x -= x + width - windowWidth), y + height > windowHeight && (y -= 20 + height), Tooltip.prototype.setPosition.call(this, x, y); + }; + }).call(GutterTooltip.prototype), exports.GutterHandler = function(mouseHandler) { + var tooltipTimeout, mouseEvent, tooltipAnnotation, editor = mouseHandler.editor, gutter = editor.renderer.$gutterLayer, tooltip = new GutterTooltip(editor.container); + function hideTooltip() { + tooltipTimeout && (tooltipTimeout = clearTimeout(tooltipTimeout)), tooltipAnnotation && (tooltip.hide(), tooltipAnnotation = null, editor._signal("hideGutterTooltip", tooltip), editor.off("mousewheel", hideTooltip)); + } + function moveTooltip(e) { + tooltip.setPosition(e.x, e.y); + } + mouseHandler.editor.setDefaultHandler("guttermousedown", function(e) { + if (editor.isFocused() && 0 == e.getButton() && "foldWidgets" != gutter.getRegion(e)) { + var row = e.getDocumentPosition().row, selection = editor.session.selection; + if (e.getShiftKey()) selection.selectTo(row, 0); + else { + if (2 == e.domEvent.detail) return editor.selectAll(), e.preventDefault(); + mouseHandler.$clickSelection = editor.selection.getLineRange(row); + } + return mouseHandler.setState("selectByLines"), mouseHandler.captureMouse(e), e.preventDefault(); + } + }), mouseHandler.editor.setDefaultHandler("guttermousemove", function(e) { + var target = e.domEvent.target || e.domEvent.srcElement; + if (dom.hasCssClass(target, "ace_fold-widget")) return hideTooltip(); + tooltipAnnotation && mouseHandler.$tooltipFollowsMouse && moveTooltip(e), mouseEvent = e, tooltipTimeout || (tooltipTimeout = setTimeout(function() { + tooltipTimeout = null, mouseEvent && !mouseHandler.isMousePressed ? function() { + var row = mouseEvent.getDocumentPosition().row, annotation = gutter.$annotations[row]; + if (!annotation) return hideTooltip(); + if (row == editor.session.getLength()) { + var screenRow = editor.renderer.pixelToScreenCoordinates(0, mouseEvent.y).row, pos = mouseEvent.$pos; + if (screenRow > editor.session.documentToScreenRow(pos.row, pos.column)) return hideTooltip(); + } + if (tooltipAnnotation != annotation) if (tooltipAnnotation = annotation.text.join("
"), tooltip.setHtml(tooltipAnnotation), tooltip.show(), editor._signal("showGutterTooltip", tooltip), editor.on("mousewheel", hideTooltip), mouseHandler.$tooltipFollowsMouse) moveTooltip(mouseEvent); + else { + var rect = mouseEvent.domEvent.target.getBoundingClientRect(), style = tooltip.getElement().style; + style.left = rect.right + "px", style.top = rect.bottom + "px"; + } + }() : hideTooltip(); + }, 50)); + }), event.addListener(editor.renderer.$gutter, "mouseout", function(e) { + mouseEvent = null, tooltipAnnotation && !tooltipTimeout && (tooltipTimeout = setTimeout(function() { + tooltipTimeout = null, hideTooltip(); + }, 50)); + }, editor), editor.on("changeSession", hideTooltip); + }; + }), ace.define("ace/mouse/mouse_event", [ + "require", + "exports", + "module", + "ace/lib/event", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var event = require("../lib/event"), useragent = require("../lib/useragent"), MouseEvent = exports.MouseEvent = function(domEvent, editor) { + this.domEvent = domEvent, this.editor = editor, this.x = this.clientX = domEvent.clientX, this.y = this.clientY = domEvent.clientY, this.$pos = null, this.$inSelection = null, this.propagationStopped = !1, this.defaultPrevented = !1; + }; + (function() { + this.stopPropagation = function() { + event.stopPropagation(this.domEvent), this.propagationStopped = !0; + }, this.preventDefault = function() { + event.preventDefault(this.domEvent), this.defaultPrevented = !0; + }, this.stop = function() { + this.stopPropagation(), this.preventDefault(); + }, this.getDocumentPosition = function() { + return this.$pos || (this.$pos = this.editor.renderer.screenToTextCoordinates(this.clientX, this.clientY)), this.$pos; + }, this.inSelection = function() { + if (null !== this.$inSelection) return this.$inSelection; + var selectionRange = this.editor.getSelectionRange(); + if (selectionRange.isEmpty()) this.$inSelection = !1; + else { + var pos = this.getDocumentPosition(); + this.$inSelection = selectionRange.contains(pos.row, pos.column); + } + return this.$inSelection; + }, this.getButton = function() { + return event.getButton(this.domEvent); + }, this.getShiftKey = function() { + return this.domEvent.shiftKey; + }, this.getAccelKey = useragent.isMac ? function() { + return this.domEvent.metaKey; + } : function() { + return this.domEvent.ctrlKey; + }; + }).call(MouseEvent.prototype); + }), ace.define("ace/mouse/dragdrop_handler", [ + "require", + "exports", + "module", + "ace/lib/dom", + "ace/lib/event", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"), event = require("../lib/event"), useragent = require("../lib/useragent"); + function DragdropHandler(mouseHandler) { + var dragOperation, isInternal, autoScrollStartTime, cursorMovedTime, cursorPointOnCaretMoved, editor = mouseHandler.editor, dragImage = dom.createElement("div"); + dragImage.style.cssText = "top:-100px;position:absolute;z-index:2147483647;opacity:0.5", dragImage.textContent = "\xa0", [ + "dragWait", + "dragWaitEnd", + "startDrag", + "dragReadyEnd", + "onMouseDrag" + ].forEach(function(x) { + mouseHandler[x] = this[x]; + }, this), editor.on("mousedown", this.onMouseDown.bind(mouseHandler)); + var dragSelectionMarker, x1, y, timerId, range, dragCursor, mouseTarget = editor.container, counter = 0; + function onDragInterval() { + var cursor, prevCursor, now, lineHeight, characterWidth, editorRect, offsets, nearestXOffset, nearestYOffset, scrollCursor, vScroll, hScroll, vMovement, cursor1, prevCursor1, now1, vMovement1, hMovement, prevCursor2 = dragCursor; + cursor1 = dragCursor = editor.renderer.screenToTextCoordinates(x1, y), prevCursor1 = prevCursor2, now1 = Date.now(), vMovement1 = !prevCursor1 || cursor1.row != prevCursor1.row, hMovement = !prevCursor1 || cursor1.column != prevCursor1.column, !cursorMovedTime || vMovement1 || hMovement ? (editor.moveCursorToPosition(cursor1), cursorMovedTime = now1, cursorPointOnCaretMoved = { + x: x1, + y: y + }) : calcDistance(cursorPointOnCaretMoved.x, cursorPointOnCaretMoved.y, x1, y) > 5 ? cursorMovedTime = null : now1 - cursorMovedTime >= 200 && (editor.renderer.scrollCursorIntoView(), cursorMovedTime = null), cursor = dragCursor, prevCursor = prevCursor2, now = Date.now(), lineHeight = editor.renderer.layerConfig.lineHeight, characterWidth = editor.renderer.layerConfig.characterWidth, editorRect = editor.renderer.scroller.getBoundingClientRect(), offsets = { + x: { + left: x1 - editorRect.left, + right: editorRect.right - x1 + }, + y: { + top: y - editorRect.top, + bottom: editorRect.bottom - y + } + }, nearestXOffset = Math.min(offsets.x.left, offsets.x.right), nearestYOffset = Math.min(offsets.y.top, offsets.y.bottom), scrollCursor = { + row: cursor.row, + column: cursor.column + }, nearestXOffset / characterWidth <= 2 && (scrollCursor.column += offsets.x.left < offsets.x.right ? -3 : 2), nearestYOffset / lineHeight <= 1 && (scrollCursor.row += offsets.y.top < offsets.y.bottom ? -1 : 1), vScroll = cursor.row != scrollCursor.row, hScroll = cursor.column != scrollCursor.column, vMovement = !prevCursor || cursor.row != prevCursor.row, vScroll || hScroll && !vMovement ? autoScrollStartTime ? now - autoScrollStartTime >= 200 && editor.renderer.scrollCursorIntoView(scrollCursor) : autoScrollStartTime = now : autoScrollStartTime = null; + } + function addDragMarker() { + range = editor.selection.toOrientedRange(), dragSelectionMarker = editor.session.addMarker(range, "ace_selection", editor.getSelectionStyle()), editor.clearSelection(), editor.isFocused() && editor.renderer.$cursorLayer.setBlinking(!1), clearInterval(timerId), onDragInterval(), timerId = setInterval(onDragInterval, 20), counter = 0, event.addListener(document, "mousemove", onMouseMove); + } + function clearDragMarker() { + clearInterval(timerId), editor.session.removeMarker(dragSelectionMarker), dragSelectionMarker = null, editor.selection.fromOrientedRange(range), editor.isFocused() && !isInternal && editor.$resetCursorStyle(), range = null, dragCursor = null, counter = 0, autoScrollStartTime = null, cursorMovedTime = null, event.removeListener(document, "mousemove", onMouseMove); + } + this.onDragStart = function(e) { + if (this.cancelDrag || !mouseTarget.draggable) { + var self = this; + return setTimeout(function() { + self.startSelect(), self.captureMouse(e); + }, 0), e.preventDefault(); + } + range = editor.getSelectionRange(); + var dataTransfer = e.dataTransfer; + dataTransfer.effectAllowed = editor.getReadOnly() ? "copy" : "copyMove", editor.container.appendChild(dragImage), dataTransfer.setDragImage && dataTransfer.setDragImage(dragImage, 0, 0), setTimeout(function() { + editor.container.removeChild(dragImage); + }), dataTransfer.clearData(), dataTransfer.setData("Text", editor.session.getTextRange()), isInternal = !0, this.setState("drag"); + }, this.onDragEnd = function(e) { + if (mouseTarget.draggable = !1, isInternal = !1, this.setState(null), !editor.getReadOnly()) { + var dropEffect = e.dataTransfer.dropEffect; + dragOperation || "move" != dropEffect || editor.session.remove(editor.getSelectionRange()), editor.$resetCursorStyle(); + } + this.editor.unsetStyle("ace_dragging"), this.editor.renderer.setCursorStyle(""); + }, this.onDragEnter = function(e) { + if (!editor.getReadOnly() && canAccept(e.dataTransfer)) return x1 = e.clientX, y = e.clientY, dragSelectionMarker || addDragMarker(), counter++, e.dataTransfer.dropEffect = dragOperation = getDropEffect(e), event.preventDefault(e); + }, this.onDragOver = function(e) { + if (!editor.getReadOnly() && canAccept(e.dataTransfer)) return x1 = e.clientX, y = e.clientY, !dragSelectionMarker && (addDragMarker(), counter++), null !== onMouseMoveTimer && (onMouseMoveTimer = null), e.dataTransfer.dropEffect = dragOperation = getDropEffect(e), event.preventDefault(e); + }, this.onDragLeave = function(e) { + if (counter--, counter <= 0 && dragSelectionMarker) return clearDragMarker(), dragOperation = null, event.preventDefault(e); + }, this.onDrop = function(e) { + if (dragCursor) { + var dataTransfer = e.dataTransfer; + if (isInternal) switch(dragOperation){ + case "move": + range = range.contains(dragCursor.row, dragCursor.column) ? { + start: dragCursor, + end: dragCursor + } : editor.moveText(range, dragCursor); + break; + case "copy": + range = editor.moveText(range, dragCursor, !0); + break; + } + else { + var dropData = dataTransfer.getData('Text'); + range = { + start: dragCursor, + end: editor.session.insert(dragCursor, dropData) + }, editor.focus(), dragOperation = null; + } + return clearDragMarker(), event.preventDefault(e); + } + }, event.addListener(mouseTarget, "dragstart", this.onDragStart.bind(mouseHandler), editor), event.addListener(mouseTarget, "dragend", this.onDragEnd.bind(mouseHandler), editor), event.addListener(mouseTarget, "dragenter", this.onDragEnter.bind(mouseHandler), editor), event.addListener(mouseTarget, "dragover", this.onDragOver.bind(mouseHandler), editor), event.addListener(mouseTarget, "dragleave", this.onDragLeave.bind(mouseHandler), editor), event.addListener(mouseTarget, "drop", this.onDrop.bind(mouseHandler), editor); + var onMouseMoveTimer = null; + function onMouseMove() { + null == onMouseMoveTimer && (onMouseMoveTimer = setTimeout(function() { + null != onMouseMoveTimer && dragSelectionMarker && clearDragMarker(); + }, 20)); + } + function canAccept(dataTransfer) { + var types = dataTransfer.types; + return !types || Array.prototype.some.call(types, function(type) { + return 'text/plain' == type || 'Text' == type; + }); + } + function getDropEffect(e) { + var copyAllowed = [ + 'copy', + 'copymove', + 'all', + 'uninitialized' + ], copyModifierState = useragent.isMac ? e.altKey : e.ctrlKey, effectAllowed = "uninitialized"; + try { + effectAllowed = e.dataTransfer.effectAllowed.toLowerCase(); + } catch (e4) {} + var dropEffect = "none"; + return copyModifierState && copyAllowed.indexOf(effectAllowed) >= 0 ? dropEffect = "copy" : [ + 'move', + 'copymove', + 'linkmove', + 'all', + 'uninitialized' + ].indexOf(effectAllowed) >= 0 ? dropEffect = "move" : copyAllowed.indexOf(effectAllowed) >= 0 && (dropEffect = "copy"), dropEffect; + } + } + function calcDistance(ax, ay, bx, by) { + return Math.sqrt(Math.pow(bx - ax, 2) + Math.pow(by - ay, 2)); + } + (function() { + this.dragWait = function() { + Date.now() - this.mousedownEvent.time > this.editor.getDragDelay() && this.startDrag(); + }, this.dragWaitEnd = function() { + this.editor.container.draggable = !1, this.startSelect(this.mousedownEvent.getDocumentPosition()), this.selectEnd(); + }, this.dragReadyEnd = function(e) { + this.editor.$resetCursorStyle(), this.editor.unsetStyle("ace_dragging"), this.editor.renderer.setCursorStyle(""), this.dragWaitEnd(); + }, this.startDrag = function() { + this.cancelDrag = !1; + var editor = this.editor; + editor.container.draggable = !0, editor.renderer.$cursorLayer.setBlinking(!1), editor.setStyle("ace_dragging"); + var cursorStyle = useragent.isWin ? "default" : "move"; + editor.renderer.setCursorStyle(cursorStyle), this.setState("dragReady"); + }, this.onMouseDrag = function(e) { + var target = this.editor.container; + if (useragent.isIE && "dragReady" == this.state) { + var distance = calcDistance(this.mousedownEvent.x, this.mousedownEvent.y, this.x, this.y); + distance > 3 && target.dragDrop(); + } + if ("dragWait" === this.state) { + var distance = calcDistance(this.mousedownEvent.x, this.mousedownEvent.y, this.x, this.y); + distance > 0 && (target.draggable = !1, this.startSelect(this.mousedownEvent.getDocumentPosition())); + } + }, this.onMouseDown = function(e) { + if (this.$dragEnabled) { + this.mousedownEvent = e; + var editor = this.editor, inSelection = e.inSelection(), button = e.getButton(), clickCount = e.domEvent.detail || 1; + if (1 === clickCount && 0 === button && inSelection) { + if (e.editor.inMultiSelectMode && (e.getAccelKey() || e.getShiftKey())) return; + this.mousedownEvent.time = Date.now(); + var eventTarget = e.domEvent.target || e.domEvent.srcElement; + ("unselectable" in eventTarget && (eventTarget.unselectable = "on"), editor.getDragDelay()) ? (useragent.isWebKit && (this.cancelDrag = !0, editor.container.draggable = !0), this.setState("dragWait")) : this.startDrag(), this.captureMouse(e, this.onMouseDrag.bind(this)), e.defaultPrevented = !0; + } + } + }; + }).call(DragdropHandler.prototype), exports.DragdropHandler = DragdropHandler; + }), ace.define("ace/mouse/touch_handler", [ + "require", + "exports", + "module", + "ace/mouse/mouse_event", + "ace/lib/event", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var MouseEvent = require("./mouse_event").MouseEvent, event = require("../lib/event"), dom = require("../lib/dom"); + exports.addTouchListeners = function(el, editor) { + var startX, startY, touchStartT, lastT, longTouchTimer, animationTimer, pos1, pressed, contextMenu, mode = "scroll", animationSteps = 0, clickCount = 0, vX = 0, vY = 0; + function showContextMenu() { + if (!contextMenu) { + var clipboard, isOpen, updateMenu, handleClick; + clipboard = window.navigator && window.navigator.clipboard, isOpen = !1, updateMenu = function() { + var selected = editor.getCopyText(), hasUndo = editor.session.getUndoManager().hasUndo(); + contextMenu.replaceChild(dom.buildDom(isOpen ? [ + "span", + !selected && [ + "span", + { + class: "ace_mobile-button", + action: "selectall" + }, + "Select All" + ], + selected && [ + "span", + { + class: "ace_mobile-button", + action: "copy" + }, + "Copy" + ], + selected && [ + "span", + { + class: "ace_mobile-button", + action: "cut" + }, + "Cut" + ], + clipboard && [ + "span", + { + class: "ace_mobile-button", + action: "paste" + }, + "Paste" + ], + hasUndo && [ + "span", + { + class: "ace_mobile-button", + action: "undo" + }, + "Undo" + ], + [ + "span", + { + class: "ace_mobile-button", + action: "find" + }, + "Find" + ], + [ + "span", + { + class: "ace_mobile-button", + action: "openCommandPallete" + }, + "Pallete" + ] + ] : [ + "span" + ]), contextMenu.firstChild); + }, handleClick = function(e) { + var action = e.target.getAttribute("action"); + if ("more" == action || !isOpen) return isOpen = !isOpen, updateMenu(); + "paste" == action ? clipboard.readText().then(function(text) { + editor.execCommand(action, text); + }) : action && (("cut" == action || "copy" == action) && (clipboard ? clipboard.writeText(editor.getCopyText()) : document.execCommand("copy")), editor.execCommand(action)), contextMenu.firstChild.style.display = "none", isOpen = !1, "openCommandPallete" != action && editor.focus(); + }, contextMenu = dom.buildDom([ + "div", + { + class: "ace_mobile-menu", + ontouchstart: function(e) { + mode = "menu", e.stopPropagation(), e.preventDefault(), editor.textInput.focus(); + }, + ontouchend: function(e) { + e.stopPropagation(), e.preventDefault(), handleClick(e); + }, + onclick: handleClick + }, + [ + "span" + ], + [ + "span", + { + class: "ace_mobile-button", + action: "more" + }, + "..." + ] + ], editor.container); + } + var cursor = editor.selection.cursor, pagePos = editor.renderer.textToScreenCoordinates(cursor.row, cursor.column), leftOffset = editor.renderer.textToScreenCoordinates(0, 0).pageX, scrollLeft = editor.renderer.scrollLeft, rect = editor.container.getBoundingClientRect(); + contextMenu.style.top = pagePos.pageY - rect.top - 3 + "px", pagePos.pageX - rect.left < rect.width - 70 ? (contextMenu.style.left = "", contextMenu.style.right = "10px") : (contextMenu.style.right = "", contextMenu.style.left = leftOffset + scrollLeft - rect.left + "px"), contextMenu.style.display = "", contextMenu.firstChild.style.display = "none", editor.on("input", hideContextMenu); + } + function hideContextMenu(e) { + contextMenu && (contextMenu.style.display = "none"), editor.off("input", hideContextMenu); + } + function handleLongTap() { + clearTimeout(longTouchTimer = null); + var range = editor.selection.getRange(), inSelection = range.contains(pos1.row, pos1.column); + (range.isEmpty() || !inSelection) && (editor.selection.moveToPosition(pos1), editor.selection.selectWord()), mode = "wait", showContextMenu(); + } + event.addListener(el, "contextmenu", function(e) { + pressed && editor.textInput.getElement().focus(); + }, editor), event.addListener(el, "touchstart", function(e) { + var range, touches = e.touches; + if (longTouchTimer || touches.length > 1) { + clearTimeout(longTouchTimer), longTouchTimer = null, touchStartT = -1, mode = "zoom"; + return; + } + pressed = editor.$mouseHandler.isMousePressed = !0; + var h = editor.renderer.layerConfig.lineHeight, w = editor.renderer.layerConfig.lineHeight, t = e.timeStamp; + lastT = t; + var touchObj = touches[0], x2 = touchObj.clientX, y1 = touchObj.clientY; + Math.abs(startX - x2) + Math.abs(startY - y1) > h && (touchStartT = -1), startX = e.clientX = x2, startY = e.clientY = y1, vX = vY = 0; + var ev = new MouseEvent(e, editor); + if (pos1 = ev.getDocumentPosition(), t - touchStartT < 500 && 1 == touches.length && !animationSteps) clickCount++, e.preventDefault(), e.button = 0, clearTimeout(longTouchTimer = null), editor.selection.moveToPosition(pos1), (range = clickCount >= 2 ? editor.selection.getLineRange(pos1.row) : editor.session.getBracketRange(pos1)) && !range.isEmpty() ? editor.selection.setRange(range) : editor.selection.selectWord(), mode = "wait"; + else { + clickCount = 0; + var cursor = editor.selection.cursor, anchor = editor.selection.isEmpty() ? cursor : editor.selection.anchor, cursorPos = editor.renderer.$cursorLayer.getPixelPosition(cursor, !0), anchorPos = editor.renderer.$cursorLayer.getPixelPosition(anchor, !0), rect = editor.renderer.scroller.getBoundingClientRect(), offsetTop = editor.renderer.layerConfig.offset, offsetLeft = editor.renderer.scrollLeft, weightedDistance = function(x, y) { + return (x /= w) * x + (y = y / h - 0.75) * y; + }; + if (e.clientX < rect.left) { + mode = "zoom"; + return; + } + var diff1 = weightedDistance(e.clientX - rect.left - cursorPos.left + offsetLeft, e.clientY - rect.top - cursorPos.top + offsetTop), diff2 = weightedDistance(e.clientX - rect.left - anchorPos.left + offsetLeft, e.clientY - rect.top - anchorPos.top + offsetTop); + diff1 < 3.5 && diff2 < 3.5 && (mode = diff1 > diff2 ? "cursor" : "anchor"), mode = diff2 < 3.5 ? "anchor" : diff1 < 3.5 ? "cursor" : "scroll", longTouchTimer = setTimeout(handleLongTap, 450); + } + touchStartT = t; + }, editor), event.addListener(el, "touchend", function(e) { + pressed = editor.$mouseHandler.isMousePressed = !1, animationTimer && clearInterval(animationTimer), "zoom" == mode ? (mode = "", animationSteps = 0) : longTouchTimer ? (editor.selection.moveToPosition(pos1), animationSteps = 0, showContextMenu()) : "scroll" == mode ? (animationSteps += 60, animationTimer = setInterval(function() { + animationSteps-- <= 0 && (clearInterval(animationTimer), animationTimer = null), 0.01 > Math.abs(vX) && (vX = 0), 0.01 > Math.abs(vY) && (vY = 0), animationSteps < 20 && (vX *= 0.9), animationSteps < 20 && (vY *= 0.9); + var oldScrollTop = editor.session.getScrollTop(); + editor.renderer.scrollBy(10 * vX, 10 * vY), oldScrollTop == editor.session.getScrollTop() && (animationSteps = 0); + }, 10), hideContextMenu()) : showContextMenu(), clearTimeout(longTouchTimer), longTouchTimer = null; + }, editor), event.addListener(el, "touchmove", function(e) { + longTouchTimer && (clearTimeout(longTouchTimer), longTouchTimer = null); + var touches = e.touches; + if (!(touches.length > 1) && "zoom" != mode) { + var touchObj = touches[0], wheelX = startX - touchObj.clientX, wheelY = startY - touchObj.clientY; + if ("wait" == mode) { + if (!(wheelX * wheelX + wheelY * wheelY > 4)) return e.preventDefault(); + mode = "cursor"; + } + startX = touchObj.clientX, startY = touchObj.clientY, e.clientX = touchObj.clientX, e.clientY = touchObj.clientY; + var t = e.timeStamp, dt = t - lastT; + if (lastT = t, "scroll" == mode) { + var mouseEvent = new MouseEvent(e, editor); + mouseEvent.speed = 1, mouseEvent.wheelX = wheelX, mouseEvent.wheelY = wheelY, 10 * Math.abs(wheelX) < Math.abs(wheelY) && (wheelX = 0), 10 * Math.abs(wheelY) < Math.abs(wheelX) && (wheelY = 0), 0 != dt && (vX = wheelX / dt, vY = wheelY / dt), editor._emit("mousewheel", mouseEvent), mouseEvent.propagationStopped || (vX = vY = 0); + } else { + var pos = new MouseEvent(e, editor).getDocumentPosition(); + "cursor" == mode ? editor.selection.moveCursorToPosition(pos) : "anchor" == mode && editor.selection.setSelectionAnchor(pos.row, pos.column), editor.renderer.scrollCursorIntoView(pos), e.preventDefault(); + } + } + }, editor); + }; + }), ace.define("ace/lib/net", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var dom = require("./dom"); + exports.get = function(url, callback) { + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, !0), xhr.onreadystatechange = function() { + 4 === xhr.readyState && callback(xhr.responseText); + }, xhr.send(null); + }, exports.loadScript = function(path, callback) { + var head = dom.getDocumentHead(), s = document.createElement('script'); + s.src = path, head.appendChild(s), s.onload = s.onreadystatechange = function(_, isAbort) { + !isAbort && s.readyState && "loaded" != s.readyState && "complete" != s.readyState || (s = s.onload = s.onreadystatechange = null, isAbort || callback()); + }; + }, exports.qualifyURL = function(url) { + var a = document.createElement('a'); + return a.href = url, a.href; + }; + }), ace.define("ace/lib/event_emitter", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + var EventEmitter = {}, stopPropagation = function() { + this.propagationStopped = !0; + }, preventDefault = function() { + this.defaultPrevented = !0; + }; + EventEmitter._emit = EventEmitter._dispatchEvent = function(eventName, e) { + this._eventRegistry || (this._eventRegistry = {}), this._defaultHandlers || (this._defaultHandlers = {}); + var listeners = this._eventRegistry[eventName] || [], defaultHandler = this._defaultHandlers[eventName]; + if (listeners.length || defaultHandler) { + "object" == typeof e && e || (e = {}), e.type || (e.type = eventName), e.stopPropagation || (e.stopPropagation = stopPropagation), e.preventDefault || (e.preventDefault = preventDefault), listeners = listeners.slice(); + for(var i = 0; i < listeners.length && (listeners[i](e, this), !e.propagationStopped); i++); + if (defaultHandler && !e.defaultPrevented) return defaultHandler(e, this); + } + }, EventEmitter._signal = function(eventName, e) { + var listeners = (this._eventRegistry || {})[eventName]; + if (listeners) { + listeners = listeners.slice(); + for(var i = 0; i < listeners.length; i++)listeners[i](e, this); + } + }, EventEmitter.once = function(eventName, callback) { + var _self = this; + if (this.on(eventName, function newCallback() { + _self.off(eventName, newCallback), callback.apply(null, arguments); + }), !callback) return new Promise(function(resolve) { + callback = resolve; + }); + }, EventEmitter.setDefaultHandler = function(eventName, callback) { + var handlers = this._defaultHandlers; + if (handlers || (handlers = this._defaultHandlers = { + _disabled_: {} + }), handlers[eventName]) { + var old = handlers[eventName], disabled = handlers._disabled_[eventName]; + disabled || (handlers._disabled_[eventName] = disabled = []), disabled.push(old); + var i = disabled.indexOf(callback); + -1 != i && disabled.splice(i, 1); + } + handlers[eventName] = callback; + }, EventEmitter.removeDefaultHandler = function(eventName, callback) { + var handlers = this._defaultHandlers; + if (handlers) { + var disabled = handlers._disabled_[eventName]; + if (handlers[eventName] == callback) disabled && this.setDefaultHandler(eventName, disabled.pop()); + else if (disabled) { + var i = disabled.indexOf(callback); + -1 != i && disabled.splice(i, 1); + } + } + }, EventEmitter.on = EventEmitter.addEventListener = function(eventName, callback, capturing) { + this._eventRegistry = this._eventRegistry || {}; + var listeners = this._eventRegistry[eventName]; + return listeners || (listeners = this._eventRegistry[eventName] = []), -1 == listeners.indexOf(callback) && listeners[capturing ? "unshift" : "push"](callback), callback; + }, EventEmitter.off = EventEmitter.removeListener = EventEmitter.removeEventListener = function(eventName, callback) { + this._eventRegistry = this._eventRegistry || {}; + var listeners = this._eventRegistry[eventName]; + if (listeners) { + var index = listeners.indexOf(callback); + -1 !== index && listeners.splice(index, 1); + } + }, EventEmitter.removeAllListeners = function(eventName) { + eventName || (this._eventRegistry = this._defaultHandlers = void 0), this._eventRegistry && (this._eventRegistry[eventName] = void 0), this._defaultHandlers && (this._defaultHandlers[eventName] = void 0); + }, exports.EventEmitter = EventEmitter; + }), ace.define("ace/lib/app_config", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "no use strict"; + var oop = require("./oop"), EventEmitter = require("./event_emitter").EventEmitter, optionsProvider = { + setOptions: function(optList) { + Object.keys(optList).forEach(function(key) { + this.setOption(key, optList[key]); + }, this); + }, + getOptions: function(optionNames) { + var result = {}; + if (optionNames) Array.isArray(optionNames) || (result = optionNames, optionNames = Object.keys(result)); + else { + var options = this.$options; + optionNames = Object.keys(options).filter(function(key) { + return !options[key].hidden; + }); + } + return optionNames.forEach(function(key) { + result[key] = this.getOption(key); + }, this), result; + }, + setOption: function(name, value) { + if (this["$" + name] !== value) { + var opt = this.$options[name]; + if (!opt) return warn('misspelled option "' + name + '"'); + if (opt.forwardTo) return this[opt.forwardTo] && this[opt.forwardTo].setOption(name, value); + opt.handlesSet || (this["$" + name] = value), opt && opt.set && opt.set.call(this, value); + } + }, + getOption: function(name) { + var opt = this.$options[name]; + return opt ? opt.forwardTo ? this[opt.forwardTo] && this[opt.forwardTo].getOption(name) : opt && opt.get ? opt.get.call(this) : this["$" + name] : warn('misspelled option "' + name + '"'); + } + }; + function warn(message) { + "undefined" != typeof console && console.warn && console.warn.apply(console, arguments); + } + function reportError(msg, data) { + var e = new Error(msg); + e.data = data, "object" == typeof console && console.error && console.error(e), setTimeout(function() { + throw e; + }); + } + var AppConfig = function() { + this.$defaultOptions = {}; + }; + (function() { + oop.implement(this, EventEmitter), this.defineOptions = function(obj, path, options) { + return obj.$options || (this.$defaultOptions[path] = obj.$options = {}), Object.keys(options).forEach(function(key) { + var opt = options[key]; + "string" == typeof opt && (opt = { + forwardTo: opt + }), opt.name || (opt.name = key), obj.$options[opt.name] = opt, "initialValue" in opt && (obj["$" + opt.name] = opt.initialValue); + }), oop.implement(obj, optionsProvider), this; + }, this.resetOptions = function(obj) { + Object.keys(obj.$options).forEach(function(key) { + var opt = obj.$options[key]; + "value" in opt && obj.setOption(key, opt.value); + }); + }, this.setDefaultValue = function(path, name, value) { + if (!path) { + for(path in this.$defaultOptions)if (this.$defaultOptions[path][name]) break; + if (!this.$defaultOptions[path][name]) return !1; + } + var opts = this.$defaultOptions[path] || (this.$defaultOptions[path] = {}); + opts[name] && (opts.forwardTo ? this.setDefaultValue(opts.forwardTo, name, value) : opts[name].value = value); + }, this.setDefaultValues = function(path, optionHash) { + Object.keys(optionHash).forEach(function(key) { + this.setDefaultValue(path, key, optionHash[key]); + }, this); + }, this.warn = warn, this.reportError = reportError; + }).call(AppConfig.prototype), exports.AppConfig = AppConfig; + }), ace.define("ace/config", [ + "require", + "exports", + "module", + "ace/lib/lang", + "ace/lib/oop", + "ace/lib/net", + "ace/lib/dom", + "ace/lib/app_config" + ], function(require, exports, module3) { + "no use strict"; + var lang = require("./lib/lang"); + require("./lib/oop"); + var net = require("./lib/net"), dom = require("./lib/dom"), AppConfig = require("./lib/app_config").AppConfig; + module3.exports = exports = new AppConfig(); + var global = function() { + return this || "undefined" != typeof window && window; + }(), options = { + packaged: !1, + workerPath: null, + modePath: null, + themePath: null, + basePath: "", + suffix: ".js", + $moduleUrls: {}, + loadWorkerFromBlob: !0, + sharedPopups: !1, + useStrictCSP: null + }; + exports.get = function(key) { + if (!options.hasOwnProperty(key)) throw new Error("Unknown config key: " + key); + return options[key]; + }, exports.set = function(key, value) { + if (options.hasOwnProperty(key)) options[key] = value; + else if (!1 == this.setDefaultValue("", key, value)) throw new Error("Unknown config key: " + key); + "useStrictCSP" == key && dom.useStrictCSP(value); + }, exports.all = function() { + return lang.copyObject(options); + }, exports.$modes = {}, exports.moduleUrl = function(name, component) { + if (options.$moduleUrls[name]) return options.$moduleUrls[name]; + var parts = name.split("/"), sep = "snippets" == (component = component || parts[parts.length - 2] || "") ? "/" : "-", base = parts[parts.length - 1]; + if ("worker" == component && "-" == sep) { + var re = new RegExp("^" + component + "[\\-_]|[\\-_]" + component + "$", "g"); + base = base.replace(re, ""); + } + (!base || base == component) && parts.length > 1 && (base = parts[parts.length - 2]); + var path = options[component + "Path"]; + return null == path ? path = options.basePath : "/" == sep && (component = sep = ""), path && "/" != path.slice(-1) && (path += "/"), path + component + sep + base + this.get("suffix"); + }, exports.setModuleUrl = function(name, subst) { + return options.$moduleUrls[name] = subst; + }, exports.$loading = {}, exports.loadModule = function(moduleName, onLoad1) { + Array.isArray(moduleName) && (moduleType = moduleName[0], moduleName = moduleName[1]); + try { + module4 = require(moduleName); + } catch (e) {} + if (module4 && !exports.$loading[moduleName]) return onLoad1 && onLoad1(module4); + if (exports.$loading[moduleName] || (exports.$loading[moduleName] = []), exports.$loading[moduleName].push(onLoad1), !(exports.$loading[moduleName].length > 1)) { + var module4, moduleType, afterLoad = function() { + require([ + moduleName + ], function(module) { + exports._emit("load.module", { + name: moduleName, + module: module + }); + var listeners = exports.$loading[moduleName]; + exports.$loading[moduleName] = null, listeners.forEach(function(onLoad) { + onLoad && onLoad(module); + }); + }); + }; + if (!exports.get("packaged")) return afterLoad(); + net.loadScript(exports.moduleUrl(moduleName, moduleType), afterLoad), reportErrorIfPathIsNotConfigured(); + } + }; + var reportErrorIfPathIsNotConfigured = function() { + options.basePath || options.workerPath || options.modePath || options.themePath || Object.keys(options.$moduleUrls).length || (console.error("Unable to infer path to ace from script src,", "use ace.config.set('basePath', 'path') to enable dynamic loading of modes and themes", "or with webpack use ace/webpack-resolver"), reportErrorIfPathIsNotConfigured = function() {}); + }; + function init(packaged) { + if (global && global.document) { + options.packaged = packaged || require.packaged || module3.packaged || global.define && __webpack_require__.amdD.packaged; + for(var scriptOptions = {}, scriptUrl = "", currentScript = document.currentScript || document._currentScript, scripts = (currentScript && currentScript.ownerDocument || document).getElementsByTagName("script"), i = 0; i < scripts.length; i++){ + var script = scripts[i], src = script.src || script.getAttribute("src"); + if (src) { + for(var attributes = script.attributes, j = 0, l = attributes.length; j < l; j++){ + var attr = attributes[j]; + 0 === attr.name.indexOf("data-ace-") && (scriptOptions[deHyphenate(attr.name.replace(/^data-ace-/, ""))] = attr.value); + } + var m = src.match(/^(.*)\/ace(\-\w+)?\.js(\?|$)/); + m && (scriptUrl = m[1]); + } + } + for(var key in scriptUrl && (scriptOptions.base = scriptOptions.base || scriptUrl, scriptOptions.packaged = !0), scriptOptions.basePath = scriptOptions.base, scriptOptions.workerPath = scriptOptions.workerPath || scriptOptions.base, scriptOptions.modePath = scriptOptions.modePath || scriptOptions.base, scriptOptions.themePath = scriptOptions.themePath || scriptOptions.base, delete scriptOptions.base, scriptOptions)void 0 !== scriptOptions[key] && exports.set(key, scriptOptions[key]); + } + } + function deHyphenate(str) { + return str.replace(/-(.)/g, function(m, m1) { + return m1.toUpperCase(); + }); + } + init(!0), exports.init = init, exports.version = "1.4.13"; + }), ace.define("ace/mouse/mouse_handler", [ + "require", + "exports", + "module", + "ace/lib/event", + "ace/lib/useragent", + "ace/mouse/default_handlers", + "ace/mouse/default_gutter_handler", + "ace/mouse/mouse_event", + "ace/mouse/dragdrop_handler", + "ace/mouse/touch_handler", + "ace/config" + ], function(require, exports, module) { + "use strict"; + var event = require("../lib/event"), useragent = require("../lib/useragent"), DefaultHandlers = require("./default_handlers").DefaultHandlers, DefaultGutterHandler = require("./default_gutter_handler").GutterHandler, MouseEvent = require("./mouse_event").MouseEvent, DragdropHandler = require("./dragdrop_handler").DragdropHandler, addTouchListeners = require("./touch_handler").addTouchListeners, config = require("../config"), MouseHandler = function(editor) { + var _self = this; + this.editor = editor, new DefaultHandlers(this), new DefaultGutterHandler(this), new DragdropHandler(this); + var focusEditor = function(e) { + document.hasFocus && document.hasFocus() && (editor.isFocused() || document.activeElement != (editor.textInput && editor.textInput.getElement())) || window.focus(), editor.focus(); + }, mouseTarget = editor.renderer.getMouseEventTarget(); + event.addListener(mouseTarget, "click", this.onMouseEvent.bind(this, "click"), editor), event.addListener(mouseTarget, "mousemove", this.onMouseMove.bind(this, "mousemove"), editor), event.addMultiMouseDownListener([ + mouseTarget, + editor.renderer.scrollBarV && editor.renderer.scrollBarV.inner, + editor.renderer.scrollBarH && editor.renderer.scrollBarH.inner, + editor.textInput && editor.textInput.getElement() + ].filter(Boolean), [ + 400, + 300, + 250 + ], this, "onMouseEvent", editor), event.addMouseWheelListener(editor.container, this.onMouseWheel.bind(this, "mousewheel"), editor), addTouchListeners(editor.container, editor); + var gutterEl = editor.renderer.$gutter; + event.addListener(gutterEl, "mousedown", this.onMouseEvent.bind(this, "guttermousedown"), editor), event.addListener(gutterEl, "click", this.onMouseEvent.bind(this, "gutterclick"), editor), event.addListener(gutterEl, "dblclick", this.onMouseEvent.bind(this, "gutterdblclick"), editor), event.addListener(gutterEl, "mousemove", this.onMouseEvent.bind(this, "guttermousemove"), editor), event.addListener(mouseTarget, "mousedown", focusEditor, editor), event.addListener(gutterEl, "mousedown", focusEditor, editor), useragent.isIE && editor.renderer.scrollBarV && (event.addListener(editor.renderer.scrollBarV.element, "mousedown", focusEditor, editor), event.addListener(editor.renderer.scrollBarH.element, "mousedown", focusEditor, editor)), editor.on("mousemove", function(e) { + if (!_self.state && !_self.$dragDelay && _self.$dragEnabled) { + var character = editor.renderer.screenToTextCoordinates(e.x, e.y), range = editor.session.selection.getRange(), renderer = editor.renderer; + !range.isEmpty() && range.insideStart(character.row, character.column) ? renderer.setCursorStyle("default") : renderer.setCursorStyle(""); + } + }, editor); + }; + (function() { + this.onMouseEvent = function(name, e) { + this.editor.session && this.editor._emit(name, new MouseEvent(e, this.editor)); + }, this.onMouseMove = function(name, e) { + var listeners = this.editor._eventRegistry && this.editor._eventRegistry.mousemove; + listeners && listeners.length && this.editor._emit(name, new MouseEvent(e, this.editor)); + }, this.onMouseWheel = function(name, e) { + var mouseEvent = new MouseEvent(e, this.editor); + mouseEvent.speed = 2 * this.$scrollSpeed, mouseEvent.wheelX = e.wheelX, mouseEvent.wheelY = e.wheelY, this.editor._emit(name, mouseEvent); + }, this.setState = function(state) { + this.state = state; + }, this.captureMouse = function(ev, mouseMoveHandler) { + this.x = ev.x, this.y = ev.y, this.isMousePressed = !0; + var editor = this.editor, renderer = this.editor.renderer; + renderer.$isMousePressed = !0; + var self = this, onMouseMove = function(e) { + if (e) { + if (useragent.isWebKit && !e.which && self.releaseMouse) return self.releaseMouse(); + self.x = e.clientX, self.y = e.clientY, mouseMoveHandler && mouseMoveHandler(e), self.mouseEvent = new MouseEvent(e, self.editor), self.$mouseMoved = !0; + } + }, onCaptureEnd = function(e) { + editor.off("beforeEndOperation", onOperationEnd), clearInterval(timerId), editor.session && onCaptureInterval(), self[self.state + "End"] && self[self.state + "End"](e), self.state = "", self.isMousePressed = renderer.$isMousePressed = !1, renderer.$keepTextAreaAtCursor && renderer.$moveTextAreaToCursor(), self.$onCaptureMouseMove = self.releaseMouse = null, e && self.onMouseEvent("mouseup", e), editor.endOperation(); + }, onCaptureInterval = function() { + self[self.state] && self[self.state](), self.$mouseMoved = !1; + }; + if (useragent.isOldIE && "dblclick" == ev.domEvent.type) return setTimeout(function() { + onCaptureEnd(ev); + }); + var onOperationEnd = function(e) { + self.releaseMouse && editor.curOp.command.name && editor.curOp.selectionChanged && (self[self.state + "End"] && self[self.state + "End"](), self.state = "", self.releaseMouse()); + }; + editor.on("beforeEndOperation", onOperationEnd), editor.startOperation({ + command: { + name: "mouse" + } + }), self.$onCaptureMouseMove = onMouseMove, self.releaseMouse = event.capture(this.editor.container, onMouseMove, onCaptureEnd); + var timerId = setInterval(onCaptureInterval, 20); + }, this.releaseMouse = null, this.cancelContextMenu = function() { + var stop = (function(e) { + (!e || !e.domEvent || "contextmenu" == e.domEvent.type) && (this.editor.off("nativecontextmenu", stop), e && e.domEvent && event.stopEvent(e.domEvent)); + }).bind(this); + setTimeout(stop, 10), this.editor.on("nativecontextmenu", stop); + }, this.destroy = function() { + this.releaseMouse && this.releaseMouse(); + }; + }).call(MouseHandler.prototype), config.defineOptions(MouseHandler.prototype, "mouseHandler", { + scrollSpeed: { + initialValue: 2 + }, + dragDelay: { + initialValue: useragent.isMac ? 150 : 0 + }, + dragEnabled: { + initialValue: !0 + }, + focusTimeout: { + initialValue: 0 + }, + tooltipFollowsMouse: { + initialValue: !0 + } + }), exports.MouseHandler = MouseHandler; + }), ace.define("ace/mouse/fold_handler", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"); + exports.FoldHandler = function(editor) { + editor.on("click", function(e) { + var position = e.getDocumentPosition(), session = editor.session, fold = session.getFoldAt(position.row, position.column, 1); + fold && (e.getAccelKey() ? session.removeFold(fold) : session.expandFold(fold), e.stop()); + var target = e.domEvent && e.domEvent.target; + target && dom.hasCssClass(target, "ace_inline_button") && dom.hasCssClass(target, "ace_toggle_wrap") && (session.setOption("wrap", !session.getUseWrapMode()), editor.renderer.scrollCursorIntoView()); + }), editor.on("gutterclick", function(e) { + if ("foldWidgets" == editor.renderer.$gutterLayer.getRegion(e)) { + var row = e.getDocumentPosition().row, session = editor.session; + session.foldWidgets && session.foldWidgets[row] && editor.session.onFoldWidgetClick(row, e), editor.isFocused() || editor.focus(), e.stop(); + } + }), editor.on("gutterdblclick", function(e) { + if ("foldWidgets" == editor.renderer.$gutterLayer.getRegion(e)) { + var row = e.getDocumentPosition().row, session = editor.session, data = session.getParentFoldRangeData(row, !0), range = data.range || data.firstRange; + if (range) { + row = range.start.row; + var fold = session.getFoldAt(row, session.getLine(row).length, 1); + fold ? session.removeFold(fold) : (session.addFold("...", range), editor.renderer.scrollCursorIntoView({ + row: range.start.row, + column: 0 + })); + } + e.stop(); + } + }); + }; + }), ace.define("ace/keyboard/keybinding", [ + "require", + "exports", + "module", + "ace/lib/keys", + "ace/lib/event" + ], function(require, exports, module) { + "use strict"; + var keyUtil = require("../lib/keys"), event = require("../lib/event"), KeyBinding = function(editor) { + this.$editor = editor, this.$data = { + editor: editor + }, this.$handlers = [], this.setDefaultHandler(editor.commands); + }; + (function() { + this.setDefaultHandler = function(kb) { + this.removeKeyboardHandler(this.$defaultHandler), this.$defaultHandler = kb, this.addKeyboardHandler(kb, 0); + }, this.setKeyboardHandler = function(kb) { + var h = this.$handlers; + if (h[h.length - 1] != kb) { + for(; h[h.length - 1] && h[h.length - 1] != this.$defaultHandler;)this.removeKeyboardHandler(h[h.length - 1]); + this.addKeyboardHandler(kb, 1); + } + }, this.addKeyboardHandler = function(kb, pos) { + if (kb) { + "function" != typeof kb || kb.handleKeyboard || (kb.handleKeyboard = kb); + var i = this.$handlers.indexOf(kb); + -1 != i && this.$handlers.splice(i, 1), void 0 == pos ? this.$handlers.push(kb) : this.$handlers.splice(pos, 0, kb), -1 == i && kb.attach && kb.attach(this.$editor); + } + }, this.removeKeyboardHandler = function(kb) { + var i = this.$handlers.indexOf(kb); + return -1 != i && (this.$handlers.splice(i, 1), kb.detach && kb.detach(this.$editor), !0); + }, this.getKeyboardHandler = function() { + return this.$handlers[this.$handlers.length - 1]; + }, this.getStatusText = function() { + var data = this.$data, editor = data.editor; + return this.$handlers.map(function(h) { + return h.getStatusText && h.getStatusText(editor, data) || ""; + }).filter(Boolean).join(" "); + }, this.$callKeyboardHandlers = function(hashId, keyString, keyCode, e) { + for(var toExecute, success = !1, commands = this.$editor.commands, i = this.$handlers.length; (i--) && (!(toExecute = this.$handlers[i].handleKeyboard(this.$data, hashId, keyString, keyCode, e)) || !toExecute.command || ((success = "null" == toExecute.command || commands.exec(toExecute.command, this.$editor, toExecute.args, e)) && e && -1 != hashId && !0 != toExecute.passEvent && !0 != toExecute.command.passEvent && event.stopEvent(e), !success));); + return success || -1 != hashId || (toExecute = { + command: "insertstring" + }, success = commands.exec("insertstring", this.$editor, keyString)), success && this.$editor._signal && this.$editor._signal("keyboardActivity", toExecute), success; + }, this.onCommandKey = function(e, hashId, keyCode) { + var keyString = keyUtil.keyCodeToString(keyCode); + return this.$callKeyboardHandlers(hashId, keyString, keyCode, e); + }, this.onTextInput = function(text) { + return this.$callKeyboardHandlers(-1, text); + }; + }).call(KeyBinding.prototype), exports.KeyBinding = KeyBinding; + }), ace.define("ace/lib/bidiutil", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + var dir = 0, hiLevel = 0, lastArabic = !1, hasUBAT_AL = !1, hasUBAT_B = !1, hasUBAT_S = !1, impTab_LTR = [ + [ + 0, + 3, + 0, + 1, + 0, + 0, + 0 + ], + [ + 0, + 3, + 0, + 1, + 2, + 2, + 0 + ], + [ + 0, + 3, + 0, + 17, + 2, + 0, + 1 + ], + [ + 0, + 3, + 5, + 5, + 4, + 1, + 0 + ], + [ + 0, + 3, + 21, + 21, + 4, + 0, + 1 + ], + [ + 0, + 3, + 5, + 5, + 4, + 2, + 0 + ] + ], impTab_RTL = [ + [ + 2, + 0, + 1, + 1, + 0, + 1, + 0 + ], + [ + 2, + 0, + 1, + 1, + 0, + 2, + 0 + ], + [ + 2, + 0, + 2, + 1, + 3, + 2, + 0 + ], + [ + 2, + 0, + 2, + 33, + 3, + 1, + 1 + ] + ], UnicodeTBL00 = [ + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 6, + 5, + 6, + 8, + 5, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 5, + 5, + 5, + 6, + 8, + 4, + 4, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 10, + 9, + 10, + 9, + 9, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 2, + 9, + 4, + 4, + 4, + 4, + 4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 4, + 4, + 4, + 4, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 4, + 4, + 18, + 18, + 18, + 18, + 18, + 18, + 5, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 18, + 9, + 4, + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 0, + 4, + 4, + 18, + 4, + 4, + 11, + 11, + 2, + 2, + 4, + 0, + 4, + 4, + 4, + 2, + 0, + 4, + 4, + 4, + 4, + 4 + ], UnicodeTBL20 = [ + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 8, + 18, + 18, + 18, + 0, + 1, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 8, + 5, + 13, + 14, + 15, + 16, + 17, + 9, + 11, + 11, + 11, + 11, + 11, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 9, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 4, + 8 + ]; + function _invertLevel(lev, levels, _array) { + if (!(hiLevel < lev)) { + if (1 == lev && 1 == dir && !hasUBAT_B) { + _array.reverse(); + return; + } + for(var end, lo, hi, tmp, len = _array.length, start = 0; start < len;){ + if (levels[start] >= lev) { + for(end = start + 1; end < len && levels[end] >= lev;)end++; + for(lo = start, hi = end - 1; lo < hi; lo++, hi--)tmp = _array[lo], _array[lo] = _array[hi], _array[hi] = tmp; + start = end; + } + start++; + } + } + } + function _getCharClass(chars, types, classes, ix) { + var wType, nType, len, i, cType = types[ix]; + switch(cType){ + case 0: + case 1: + lastArabic = !1; + case 4: + case 3: + return cType; + case 2: + return lastArabic ? 3 : 2; + case 7: + return lastArabic = !0, hasUBAT_AL = !0, 1; + case 8: + return 4; + case 9: + if (ix < 1 || ix + 1 >= types.length || 2 != (wType = classes[ix - 1]) && 3 != wType || 2 != (nType = types[ix + 1]) && 3 != nType) return 4; + return lastArabic && (nType = 3), nType == wType ? nType : 4; + case 10: + if (2 == (wType = ix > 0 ? classes[ix - 1] : 5) && ix + 1 < types.length && 2 == types[ix + 1]) return 2; + return 4; + case 11: + if (ix > 0 && 2 == classes[ix - 1]) return 2; + if (lastArabic) return 4; + for(i = ix + 1, len = types.length; i < len && 11 == types[i];)i++; + if (i < len && 2 == types[i]) return 2; + return 4; + case 12: + for(len = types.length, i = ix + 1; i < len && 12 == types[i];)i++; + if (i < len) { + var c = chars[ix], rtlCandidate = c >= 1425 && c <= 2303 || 64286 == c; + if (wType = types[i], rtlCandidate && (1 == wType || 7 == wType)) return 1; + } + if (ix < 1 || 5 == (wType = types[ix - 1])) return 4; + return classes[ix - 1]; + case 5: + return lastArabic = !1, hasUBAT_B = !0, dir; + case 6: + return hasUBAT_S = !0, 4; + case 13: + case 14: + case 16: + case 17: + case 15: + lastArabic = !1; + case 18: + return 4; + } + } + function _getCharacterType(ch) { + var uc = ch.charCodeAt(0), hi = uc >> 8; + return 0 == hi ? uc > 191 ? 0 : UnicodeTBL00[uc] : 5 == hi ? /[\u0591-\u05f4]/.test(ch) ? 1 : 0 : 6 == hi ? /[\u0610-\u061a\u064b-\u065f\u06d6-\u06e4\u06e7-\u06ed]/.test(ch) ? 12 : /[\u0660-\u0669\u066b-\u066c]/.test(ch) ? 3 : 1642 == uc ? 11 : /[\u06f0-\u06f9]/.test(ch) ? 2 : 7 : 32 == hi && uc <= 8287 ? UnicodeTBL20[255 & uc] : 254 == hi && uc >= 65136 ? 7 : 4; + } + exports.L = 0, exports.R = 1, exports.EN = 2, exports.ON_R = 3, exports.AN = 4, exports.R_H = 5, exports.B = 6, exports.RLE = 7, exports.DOT = "\xB7", exports.doBidiReorder = function(text, textCharTypes, isRtl) { + if (text.length < 2) return {}; + var chars1 = text.split(""), logicalFromVisual = new Array(chars1.length), bidiLevels = new Array(chars1.length), levels1 = []; + dir = isRtl ? 1 : 0, function(chars, levels, len, charTypes) { + var impTab = dir ? impTab_RTL : impTab_LTR, prevState = null, newClass = null, newLevel = null, newState = 0, action = null, condPos = -1, i = null, ix = null, classes = []; + if (!charTypes) for(i = 0, charTypes = []; i < len; i++)charTypes[i] = _getCharacterType(chars[i]); + for(ix = 0, hiLevel = dir, lastArabic = !1, hasUBAT_AL = !1, hasUBAT_B = !1, hasUBAT_S = !1; ix < len; ix++){ + if (prevState = newState, classes[ix] = newClass = _getCharClass(chars, charTypes, classes, ix), action = 240 & (newState = impTab[prevState][newClass]), newState &= 15, levels[ix] = newLevel = impTab[newState][5], action > 0) if (16 == action) { + for(i = condPos; i < ix; i++)levels[i] = 1; + condPos = -1; + } else condPos = -1; + if (impTab[newState][6]) -1 == condPos && (condPos = ix); + else if (condPos > -1) { + for(i = condPos; i < ix; i++)levels[i] = newLevel; + condPos = -1; + } + 5 == charTypes[ix] && (levels[ix] = 0), hiLevel |= newLevel; + } + if (hasUBAT_S) { + for(i = 0; i < len; i++)if (6 == charTypes[i]) { + levels[i] = dir; + for(var j = i - 1; j >= 0; j--)if (8 == charTypes[j]) levels[j] = dir; + else break; + } + } + }(chars1, levels1, chars1.length, textCharTypes); + for(var i2 = 0; i2 < logicalFromVisual.length; logicalFromVisual[i2] = i2, i2++); + _invertLevel(2, levels1, logicalFromVisual), _invertLevel(1, levels1, logicalFromVisual); + for(var i2 = 0; i2 < logicalFromVisual.length - 1; i2++)3 === textCharTypes[i2] ? levels1[i2] = exports.AN : 1 === levels1[i2] && (textCharTypes[i2] > 7 && textCharTypes[i2] < 13 || 4 === textCharTypes[i2] || 18 === textCharTypes[i2]) ? levels1[i2] = exports.ON_R : i2 > 0 && '\u0644' === chars1[i2 - 1] && /\u0622|\u0623|\u0625|\u0627/.test(chars1[i2]) && (levels1[i2 - 1] = levels1[i2] = exports.R_H, i2++); + chars1[chars1.length - 1] === exports.DOT && (levels1[chars1.length - 1] = exports.B), '\u202B' === chars1[0] && (levels1[0] = exports.RLE); + for(var i2 = 0; i2 < logicalFromVisual.length; i2++)bidiLevels[i2] = levels1[logicalFromVisual[i2]]; + return { + logicalFromVisual: logicalFromVisual, + bidiLevels: bidiLevels + }; + }, exports.hasBidiCharacters = function(text, textCharTypes) { + for(var ret = !1, i = 0; i < text.length; i++)textCharTypes[i] = _getCharacterType(text.charAt(i)), ret || 1 != textCharTypes[i] && 7 != textCharTypes[i] && 3 != textCharTypes[i] || (ret = !0); + return ret; + }, exports.getVisualFromLogicalIdx = function(logIdx, rowMap) { + for(var i = 0; i < rowMap.logicalFromVisual.length; i++)if (rowMap.logicalFromVisual[i] == logIdx) return i; + return 0; + }; + }), ace.define("ace/bidihandler", [ + "require", + "exports", + "module", + "ace/lib/bidiutil", + "ace/lib/lang" + ], function(require, exports, module) { + "use strict"; + var bidiUtil = require("./lib/bidiutil"), lang = require("./lib/lang"), bidiRE = /[\u0590-\u05f4\u0600-\u06ff\u0700-\u08ac\u202B]/, BidiHandler = function(session) { + this.session = session, this.bidiMap = {}, this.currentRow = null, this.bidiUtil = bidiUtil, this.charWidths = [], this.EOL = "\xAC", this.showInvisibles = !0, this.isRtlDir = !1, this.$isRtl = !1, this.line = "", this.wrapIndent = 0, this.EOF = "\xB6", this.RLE = "\u202B", this.contentWidth = 0, this.fontMetrics = null, this.rtlLineOffset = 0, this.wrapOffset = 0, this.isMoveLeftOperation = !1, this.seenBidi = bidiRE.test(session.getValue()); + }; + (function() { + this.isBidiRow = function(screenRow, docRow, splitIndex) { + return !!this.seenBidi && (screenRow !== this.currentRow && (this.currentRow = screenRow, this.updateRowLine(docRow, splitIndex), this.updateBidiMap()), this.bidiMap.bidiLevels); + }, this.onChange = function(delta) { + this.seenBidi ? this.currentRow = null : "insert" == delta.action && bidiRE.test(delta.lines.join("\n")) && (this.seenBidi = !0, this.currentRow = null); + }, this.getDocumentRow = function() { + var docRow = 0, rowCache = this.session.$screenRowCache; + if (rowCache.length) { + var index = this.session.$getRowCacheIndex(rowCache, this.currentRow); + index >= 0 && (docRow = this.session.$docRowCache[index]); + } + return docRow; + }, this.getSplitIndex = function() { + var splitIndex = 0, rowCache = this.session.$screenRowCache; + if (rowCache.length) for(var currentIndex, prevIndex = this.session.$getRowCacheIndex(rowCache, this.currentRow); this.currentRow - splitIndex > 0 && (currentIndex = this.session.$getRowCacheIndex(rowCache, this.currentRow - splitIndex - 1)) === prevIndex;)prevIndex = currentIndex, splitIndex++; + else splitIndex = this.currentRow; + return splitIndex; + }, this.updateRowLine = function(docRow, splitIndex) { + void 0 === docRow && (docRow = this.getDocumentRow()); + var endOfLine = docRow === this.session.getLength() - 1 ? this.EOF : this.EOL; + if (this.wrapIndent = 0, this.line = this.session.getLine(docRow), this.isRtlDir = this.$isRtl || this.line.charAt(0) === this.RLE, this.session.$useWrapMode) { + var splits = this.session.$wrapData[docRow]; + splits && (void 0 === splitIndex && (splitIndex = this.getSplitIndex()), splitIndex > 0 && splits.length ? (this.wrapIndent = splits.indent, this.wrapOffset = this.wrapIndent * this.charWidths[bidiUtil.L], this.line = splitIndex < splits.length ? this.line.substring(splits[splitIndex - 1], splits[splitIndex]) : this.line.substring(splits[splits.length - 1])) : this.line = this.line.substring(0, splits[splitIndex])), splitIndex == splits.length && (this.line += this.showInvisibles ? endOfLine : bidiUtil.DOT); + } else this.line += this.showInvisibles ? endOfLine : bidiUtil.DOT; + var size, session = this.session, shift = 0; + this.line = this.line.replace(/\t|[\u1100-\u2029, \u202F-\uFFE6]/g, function(ch, i) { + return '\t' === ch || session.isFullWidth(ch.charCodeAt(0)) ? (shift += (size = '\t' === ch ? session.getScreenTabSize(i + shift) : 2) - 1, lang.stringRepeat(bidiUtil.DOT, size)) : ch; + }), this.isRtlDir && (this.fontMetrics.$main.textContent = this.line.charAt(this.line.length - 1) == bidiUtil.DOT ? this.line.substr(0, this.line.length - 1) : this.line, this.rtlLineOffset = this.contentWidth - this.fontMetrics.$main.getBoundingClientRect().width); + }, this.updateBidiMap = function() { + var textCharTypes = []; + bidiUtil.hasBidiCharacters(this.line, textCharTypes) || this.isRtlDir ? this.bidiMap = bidiUtil.doBidiReorder(this.line, textCharTypes, this.isRtlDir) : this.bidiMap = {}; + }, this.markAsDirty = function() { + this.currentRow = null; + }, this.updateCharacterWidths = function(fontMetrics) { + if (this.characterWidth !== fontMetrics.$characterSize.width) { + this.fontMetrics = fontMetrics; + var characterWidth = this.characterWidth = fontMetrics.$characterSize.width, bidiCharWidth = fontMetrics.$measureCharWidth("\u05d4"); + this.charWidths[bidiUtil.L] = this.charWidths[bidiUtil.EN] = this.charWidths[bidiUtil.ON_R] = characterWidth, this.charWidths[bidiUtil.R] = this.charWidths[bidiUtil.AN] = bidiCharWidth, this.charWidths[bidiUtil.R_H] = 0.45 * bidiCharWidth, this.charWidths[bidiUtil.B] = this.charWidths[bidiUtil.RLE] = 0, this.currentRow = null; + } + }, this.setShowInvisibles = function(showInvisibles) { + this.showInvisibles = showInvisibles, this.currentRow = null; + }, this.setEolChar = function(eolChar) { + this.EOL = eolChar; + }, this.setContentWidth = function(width) { + this.contentWidth = width; + }, this.isRtlLine = function(row) { + return !!this.$isRtl || (void 0 != row ? this.session.getLine(row).charAt(0) == this.RLE : this.isRtlDir); + }, this.setRtlDirection = function(editor, isRtlDir) { + for(var cursor = editor.getCursorPosition(), row = editor.selection.getSelectionAnchor().row; row <= cursor.row; row++)isRtlDir || editor.session.getLine(row).charAt(0) !== editor.session.$bidiHandler.RLE ? isRtlDir && editor.session.getLine(row).charAt(0) !== editor.session.$bidiHandler.RLE && editor.session.doc.insert({ + column: 0, + row: row + }, editor.session.$bidiHandler.RLE) : editor.session.doc.removeInLine(row, 0, 1); + }, this.getPosLeft = function(col) { + col -= this.wrapIndent; + var leftBoundary = this.line.charAt(0) === this.RLE ? 1 : 0, logicalIdx = col > leftBoundary ? this.session.getOverwrite() ? col : col - 1 : leftBoundary, visualIdx = bidiUtil.getVisualFromLogicalIdx(logicalIdx, this.bidiMap), levels = this.bidiMap.bidiLevels, left = 0; + !this.session.getOverwrite() && col <= leftBoundary && levels[visualIdx] % 2 != 0 && visualIdx++; + for(var i = 0; i < visualIdx; i++)left += this.charWidths[levels[i]]; + return !this.session.getOverwrite() && col > leftBoundary && levels[visualIdx] % 2 == 0 && (left += this.charWidths[levels[visualIdx]]), this.wrapIndent && (left += this.isRtlDir ? -1 * this.wrapOffset : this.wrapOffset), this.isRtlDir && (left += this.rtlLineOffset), left; + }, this.getSelections = function(startCol, endCol) { + var level, map = this.bidiMap, levels = map.bidiLevels, selections = [], offset = 0, selColMin = Math.min(startCol, endCol) - this.wrapIndent, selColMax = Math.max(startCol, endCol) - this.wrapIndent, isSelected = !1, isSelectedPrev = !1, selectionStart = 0; + this.wrapIndent && (offset += this.isRtlDir ? -1 * this.wrapOffset : this.wrapOffset); + for(var logIdx, visIdx = 0; visIdx < levels.length; visIdx++)logIdx = map.logicalFromVisual[visIdx], level = levels[visIdx], isSelected = logIdx >= selColMin && logIdx < selColMax, isSelected && !isSelectedPrev ? selectionStart = offset : !isSelected && isSelectedPrev && selections.push({ + left: selectionStart, + width: offset - selectionStart + }), offset += this.charWidths[level], isSelectedPrev = isSelected; + if (isSelected && visIdx === levels.length && selections.push({ + left: selectionStart, + width: offset - selectionStart + }), this.isRtlDir) for(var i = 0; i < selections.length; i++)selections[i].left += this.rtlLineOffset; + return selections; + }, this.offsetToCol = function(posX) { + this.isRtlDir && (posX -= this.rtlLineOffset); + var logicalIdx = 0, posX = Math.max(posX, 0), offset = 0, visualIdx = 0, levels = this.bidiMap.bidiLevels, charWidth = this.charWidths[levels[visualIdx]]; + for(this.wrapIndent && (posX -= this.isRtlDir ? -1 * this.wrapOffset : this.wrapOffset); posX > offset + charWidth / 2;){ + if (offset += charWidth, visualIdx === levels.length - 1) { + charWidth = 0; + break; + } + charWidth = this.charWidths[levels[++visualIdx]]; + } + return visualIdx > 0 && levels[visualIdx - 1] % 2 != 0 && levels[visualIdx] % 2 == 0 ? (posX < offset && visualIdx--, logicalIdx = this.bidiMap.logicalFromVisual[visualIdx]) : visualIdx > 0 && levels[visualIdx - 1] % 2 == 0 && levels[visualIdx] % 2 != 0 ? logicalIdx = 1 + (posX > offset ? this.bidiMap.logicalFromVisual[visualIdx] : this.bidiMap.logicalFromVisual[visualIdx - 1]) : this.isRtlDir && visualIdx === levels.length - 1 && 0 === charWidth && levels[visualIdx - 1] % 2 == 0 || !this.isRtlDir && 0 === visualIdx && levels[visualIdx] % 2 != 0 ? logicalIdx = 1 + this.bidiMap.logicalFromVisual[visualIdx] : (visualIdx > 0 && levels[visualIdx - 1] % 2 != 0 && 0 !== charWidth && visualIdx--, logicalIdx = this.bidiMap.logicalFromVisual[visualIdx]), 0 === logicalIdx && this.isRtlDir && logicalIdx++, logicalIdx + this.wrapIndent; + }; + }).call(BidiHandler.prototype), exports.BidiHandler = BidiHandler; + }), ace.define("ace/selection", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/lang", + "ace/lib/event_emitter", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), lang = require("./lib/lang"), EventEmitter = require("./lib/event_emitter").EventEmitter, Range = require("./range").Range, Selection = function(session) { + this.session = session, this.doc = session.getDocument(), this.clearSelection(), this.cursor = this.lead = this.doc.createAnchor(0, 0), this.anchor = this.doc.createAnchor(0, 0), this.$silent = !1; + var self = this; + this.cursor.on("change", function(e) { + self.$cursorChanged = !0, self.$silent || self._emit("changeCursor"), self.$isEmpty || self.$silent || self._emit("changeSelection"), self.$keepDesiredColumnOnChange || e.old.column == e.value.column || (self.$desiredColumn = null); + }), this.anchor.on("change", function() { + self.$anchorChanged = !0, self.$isEmpty || self.$silent || self._emit("changeSelection"); + }); + }; + (function() { + oop.implement(this, EventEmitter), this.isEmpty = function() { + return this.$isEmpty || this.anchor.row == this.lead.row && this.anchor.column == this.lead.column; + }, this.isMultiLine = function() { + return !this.$isEmpty && this.anchor.row != this.cursor.row; + }, this.getCursor = function() { + return this.lead.getPosition(); + }, this.setSelectionAnchor = function(row, column) { + this.$isEmpty = !1, this.anchor.setPosition(row, column); + }, this.getAnchor = this.getSelectionAnchor = function() { + return this.$isEmpty ? this.getSelectionLead() : this.anchor.getPosition(); + }, this.getSelectionLead = function() { + return this.lead.getPosition(); + }, this.isBackwards = function() { + var anchor = this.anchor, lead = this.lead; + return anchor.row > lead.row || anchor.row == lead.row && anchor.column > lead.column; + }, this.getRange = function() { + var anchor = this.anchor, lead = this.lead; + return this.$isEmpty ? Range.fromPoints(lead, lead) : this.isBackwards() ? Range.fromPoints(lead, anchor) : Range.fromPoints(anchor, lead); + }, this.clearSelection = function() { + this.$isEmpty || (this.$isEmpty = !0, this._emit("changeSelection")); + }, this.selectAll = function() { + this.$setSelection(0, 0, Number.MAX_VALUE, Number.MAX_VALUE); + }, this.setRange = this.setSelectionRange = function(range, reverse) { + var start = reverse ? range.end : range.start, end = reverse ? range.start : range.end; + this.$setSelection(start.row, start.column, end.row, end.column); + }, this.$setSelection = function(anchorRow, anchorColumn, cursorRow, cursorColumn) { + if (!this.$silent) { + var wasEmpty = this.$isEmpty, wasMultiselect = this.inMultiSelectMode; + this.$silent = !0, this.$cursorChanged = this.$anchorChanged = !1, this.anchor.setPosition(anchorRow, anchorColumn), this.cursor.setPosition(cursorRow, cursorColumn), this.$isEmpty = !Range.comparePoints(this.anchor, this.cursor), this.$silent = !1, this.$cursorChanged && this._emit("changeCursor"), (this.$cursorChanged || this.$anchorChanged || wasEmpty != this.$isEmpty || wasMultiselect) && this._emit("changeSelection"); + } + }, this.$moveSelection = function(mover) { + var lead = this.lead; + this.$isEmpty && this.setSelectionAnchor(lead.row, lead.column), mover.call(this); + }, this.selectTo = function(row, column) { + this.$moveSelection(function() { + this.moveCursorTo(row, column); + }); + }, this.selectToPosition = function(pos) { + this.$moveSelection(function() { + this.moveCursorToPosition(pos); + }); + }, this.moveTo = function(row, column) { + this.clearSelection(), this.moveCursorTo(row, column); + }, this.moveToPosition = function(pos) { + this.clearSelection(), this.moveCursorToPosition(pos); + }, this.selectUp = function() { + this.$moveSelection(this.moveCursorUp); + }, this.selectDown = function() { + this.$moveSelection(this.moveCursorDown); + }, this.selectRight = function() { + this.$moveSelection(this.moveCursorRight); + }, this.selectLeft = function() { + this.$moveSelection(this.moveCursorLeft); + }, this.selectLineStart = function() { + this.$moveSelection(this.moveCursorLineStart); + }, this.selectLineEnd = function() { + this.$moveSelection(this.moveCursorLineEnd); + }, this.selectFileEnd = function() { + this.$moveSelection(this.moveCursorFileEnd); + }, this.selectFileStart = function() { + this.$moveSelection(this.moveCursorFileStart); + }, this.selectWordRight = function() { + this.$moveSelection(this.moveCursorWordRight); + }, this.selectWordLeft = function() { + this.$moveSelection(this.moveCursorWordLeft); + }, this.getWordRange = function(row, column) { + if (void 0 === column) { + var cursor = row || this.lead; + row = cursor.row, column = cursor.column; + } + return this.session.getWordRange(row, column); + }, this.selectWord = function() { + this.setSelectionRange(this.getWordRange()); + }, this.selectAWord = function() { + var cursor = this.getCursor(), range = this.session.getAWordRange(cursor.row, cursor.column); + this.setSelectionRange(range); + }, this.getLineRange = function(row, excludeLastChar) { + var rowEnd, rowStart = "number" == typeof row ? row : this.lead.row, foldLine = this.session.getFoldLine(rowStart); + return (foldLine ? (rowStart = foldLine.start.row, rowEnd = foldLine.end.row) : rowEnd = rowStart, !0 === excludeLastChar) ? new Range(rowStart, 0, rowEnd, this.session.getLine(rowEnd).length) : new Range(rowStart, 0, rowEnd + 1, 0); + }, this.selectLine = function() { + this.setSelectionRange(this.getLineRange()); + }, this.moveCursorUp = function() { + this.moveCursorBy(-1, 0); + }, this.moveCursorDown = function() { + this.moveCursorBy(1, 0); + }, this.wouldMoveIntoSoftTab = function(cursor, tabSize, direction) { + var start = cursor.column, end = cursor.column + tabSize; + return direction < 0 && (start = cursor.column - tabSize, end = cursor.column), this.session.isTabStop(cursor) && this.doc.getLine(cursor.row).slice(start, end).split(" ").length - 1 == tabSize; + }, this.moveCursorLeft = function() { + var fold, cursor = this.lead.getPosition(); + if (fold = this.session.getFoldAt(cursor.row, cursor.column, -1)) this.moveCursorTo(fold.start.row, fold.start.column); + else if (0 === cursor.column) cursor.row > 0 && this.moveCursorTo(cursor.row - 1, this.doc.getLine(cursor.row - 1).length); + else { + var tabSize = this.session.getTabSize(); + this.wouldMoveIntoSoftTab(cursor, tabSize, -1) && !this.session.getNavigateWithinSoftTabs() ? this.moveCursorBy(0, -tabSize) : this.moveCursorBy(0, -1); + } + }, this.moveCursorRight = function() { + var fold, cursor = this.lead.getPosition(); + if (fold = this.session.getFoldAt(cursor.row, cursor.column, 1)) this.moveCursorTo(fold.end.row, fold.end.column); + else if (this.lead.column == this.doc.getLine(this.lead.row).length) this.lead.row < this.doc.getLength() - 1 && this.moveCursorTo(this.lead.row + 1, 0); + else { + var tabSize = this.session.getTabSize(), cursor = this.lead; + this.wouldMoveIntoSoftTab(cursor, tabSize, 1) && !this.session.getNavigateWithinSoftTabs() ? this.moveCursorBy(0, tabSize) : this.moveCursorBy(0, 1); + } + }, this.moveCursorLineStart = function() { + var row = this.lead.row, column = this.lead.column, screenRow = this.session.documentToScreenRow(row, column), firstColumnPosition = this.session.screenToDocumentPosition(screenRow, 0), leadingSpace = this.session.getDisplayLine(row, null, firstColumnPosition.row, firstColumnPosition.column).match(/^\s*/); + leadingSpace[0].length == column || this.session.$useEmacsStyleLineStart || (firstColumnPosition.column += leadingSpace[0].length), this.moveCursorToPosition(firstColumnPosition); + }, this.moveCursorLineEnd = function() { + var lead = this.lead, lineEnd = this.session.getDocumentLastRowColumnPosition(lead.row, lead.column); + if (this.lead.column == lineEnd.column) { + var line = this.session.getLine(lineEnd.row); + if (lineEnd.column == line.length) { + var textEnd = line.search(/\s+$/); + textEnd > 0 && (lineEnd.column = textEnd); + } + } + this.moveCursorTo(lineEnd.row, lineEnd.column); + }, this.moveCursorFileEnd = function() { + var row = this.doc.getLength() - 1, column = this.doc.getLine(row).length; + this.moveCursorTo(row, column); + }, this.moveCursorFileStart = function() { + this.moveCursorTo(0, 0); + }, this.moveCursorLongWordRight = function() { + var row = this.lead.row, column = this.lead.column, line = this.doc.getLine(row), rightOfCursor = line.substring(column); + this.session.nonTokenRe.lastIndex = 0, this.session.tokenRe.lastIndex = 0; + var fold = this.session.getFoldAt(row, column, 1); + if (fold) { + this.moveCursorTo(fold.end.row, fold.end.column); + return; + } + if (this.session.nonTokenRe.exec(rightOfCursor) && (column += this.session.nonTokenRe.lastIndex, this.session.nonTokenRe.lastIndex = 0, rightOfCursor = line.substring(column)), column >= line.length) { + this.moveCursorTo(row, line.length), this.moveCursorRight(), row < this.doc.getLength() - 1 && this.moveCursorWordRight(); + return; + } + this.session.tokenRe.exec(rightOfCursor) && (column += this.session.tokenRe.lastIndex, this.session.tokenRe.lastIndex = 0), this.moveCursorTo(row, column); + }, this.moveCursorLongWordLeft = function() { + var fold, row = this.lead.row, column = this.lead.column; + if (fold = this.session.getFoldAt(row, column, -1)) { + this.moveCursorTo(fold.start.row, fold.start.column); + return; + } + var str = this.session.getFoldStringAt(row, column, -1); + null == str && (str = this.doc.getLine(row).substring(0, column)); + var leftOfCursor = lang.stringReverse(str); + if (this.session.nonTokenRe.lastIndex = 0, this.session.tokenRe.lastIndex = 0, this.session.nonTokenRe.exec(leftOfCursor) && (column -= this.session.nonTokenRe.lastIndex, leftOfCursor = leftOfCursor.slice(this.session.nonTokenRe.lastIndex), this.session.nonTokenRe.lastIndex = 0), column <= 0) { + this.moveCursorTo(row, 0), this.moveCursorLeft(), row > 0 && this.moveCursorWordLeft(); + return; + } + this.session.tokenRe.exec(leftOfCursor) && (column -= this.session.tokenRe.lastIndex, this.session.tokenRe.lastIndex = 0), this.moveCursorTo(row, column); + }, this.$shortWordEndIndex = function(rightOfCursor) { + var ch, index = 0, whitespaceRe = /\s/, tokenRe = this.session.tokenRe; + if (tokenRe.lastIndex = 0, this.session.tokenRe.exec(rightOfCursor)) index = this.session.tokenRe.lastIndex; + else { + for(; (ch = rightOfCursor[index]) && whitespaceRe.test(ch);)index++; + if (index < 1) { + for(tokenRe.lastIndex = 0; (ch = rightOfCursor[index]) && !tokenRe.test(ch);)if (tokenRe.lastIndex = 0, index++, whitespaceRe.test(ch)) { + if (index > 2) { + index--; + break; + } + for(; (ch = rightOfCursor[index]) && whitespaceRe.test(ch);)index++; + if (index > 2) break; + } + } + } + return tokenRe.lastIndex = 0, index; + }, this.moveCursorShortWordRight = function() { + var row = this.lead.row, column = this.lead.column, line = this.doc.getLine(row), rightOfCursor = line.substring(column), fold = this.session.getFoldAt(row, column, 1); + if (fold) return this.moveCursorTo(fold.end.row, fold.end.column); + if (column == line.length) { + var l = this.doc.getLength(); + do row++, rightOfCursor = this.doc.getLine(row); + while (row < l && /^\s*$/.test(rightOfCursor)) + /^\s+/.test(rightOfCursor) || (rightOfCursor = ""), column = 0; + } + var index = this.$shortWordEndIndex(rightOfCursor); + this.moveCursorTo(row, column + index); + }, this.moveCursorShortWordLeft = function() { + var fold, row = this.lead.row, column = this.lead.column; + if (fold = this.session.getFoldAt(row, column, -1)) return this.moveCursorTo(fold.start.row, fold.start.column); + var line = this.session.getLine(row).substring(0, column); + if (0 === column) { + do row--, line = this.doc.getLine(row); + while (row > 0 && /^\s*$/.test(line)) + column = line.length, /\s+$/.test(line) || (line = ""); + } + var leftOfCursor = lang.stringReverse(line), index = this.$shortWordEndIndex(leftOfCursor); + return this.moveCursorTo(row, column - index); + }, this.moveCursorWordRight = function() { + this.session.$selectLongWords ? this.moveCursorLongWordRight() : this.moveCursorShortWordRight(); + }, this.moveCursorWordLeft = function() { + this.session.$selectLongWords ? this.moveCursorLongWordLeft() : this.moveCursorShortWordLeft(); + }, this.moveCursorBy = function(rows, chars) { + var offsetX, screenPos = this.session.documentToScreenPosition(this.lead.row, this.lead.column); + if (0 === chars && (0 !== rows && (this.session.$bidiHandler.isBidiRow(screenPos.row, this.lead.row) ? (offsetX = this.session.$bidiHandler.getPosLeft(screenPos.column), screenPos.column = Math.round(offsetX / this.session.$bidiHandler.charWidths[0])) : offsetX = screenPos.column * this.session.$bidiHandler.charWidths[0]), this.$desiredColumn ? screenPos.column = this.$desiredColumn : this.$desiredColumn = screenPos.column), 0 != rows && this.session.lineWidgets && this.session.lineWidgets[this.lead.row]) { + var widget = this.session.lineWidgets[this.lead.row]; + rows < 0 ? rows -= widget.rowsAbove || 0 : rows > 0 && (rows += widget.rowCount - (widget.rowsAbove || 0)); + } + var docPos = this.session.screenToDocumentPosition(screenPos.row + rows, screenPos.column, offsetX); + 0 !== rows && 0 === chars && docPos.row === this.lead.row && docPos.column === this.lead.column, this.moveCursorTo(docPos.row, docPos.column + chars, 0 === chars); + }, this.moveCursorToPosition = function(position) { + this.moveCursorTo(position.row, position.column); + }, this.moveCursorTo = function(row, column, keepDesiredColumn) { + var fold = this.session.getFoldAt(row, column, 1); + fold && (row = fold.start.row, column = fold.start.column), this.$keepDesiredColumnOnChange = !0; + var line = this.session.getLine(row); + /[\uDC00-\uDFFF]/.test(line.charAt(column)) && line.charAt(column - 1) && (this.lead.row == row && this.lead.column == column + 1 ? column -= 1 : column += 1), this.lead.setPosition(row, column), this.$keepDesiredColumnOnChange = !1, keepDesiredColumn || (this.$desiredColumn = null); + }, this.moveCursorToScreen = function(row, column, keepDesiredColumn) { + var pos = this.session.screenToDocumentPosition(row, column); + this.moveCursorTo(pos.row, pos.column, keepDesiredColumn); + }, this.detach = function() { + this.lead.detach(), this.anchor.detach(); + }, this.fromOrientedRange = function(range) { + this.setSelectionRange(range, range.cursor == range.start), this.$desiredColumn = range.desiredColumn || this.$desiredColumn; + }, this.toOrientedRange = function(range) { + var r = this.getRange(); + return range ? (range.start.column = r.start.column, range.start.row = r.start.row, range.end.column = r.end.column, range.end.row = r.end.row) : range = r, range.cursor = this.isBackwards() ? range.start : range.end, range.desiredColumn = this.$desiredColumn, range; + }, this.getRangeOfMovements = function(func) { + var start = this.getCursor(); + try { + func(this); + var end = this.getCursor(); + return Range.fromPoints(start, end); + } catch (e) { + return Range.fromPoints(start, start); + } finally{ + this.moveCursorToPosition(start); + } + }, this.toJSON = function() { + if (this.rangeCount) var data = this.ranges.map(function(r) { + var r1 = r.clone(); + return r1.isBackwards = r.cursor == r.start, r1; + }); + else { + var data = this.getRange(); + data.isBackwards = this.isBackwards(); + } + return data; + }, this.fromJSON = function(data) { + if (void 0 == data.start) { + if (this.rangeList && data.length > 1) { + this.toSingleRange(data[0]); + for(var i = data.length; i--;){ + var r = Range.fromPoints(data[i].start, data[i].end); + data[i].isBackwards && (r.cursor = r.start), this.addRange(r, !0); + } + return; + } + data = data[0]; + } + this.rangeList && this.toSingleRange(data), this.setSelectionRange(data, data.isBackwards); + }, this.isEqual = function(data) { + if ((data.length || this.rangeCount) && data.length != this.rangeCount) return !1; + if (!data.length || !this.ranges) return this.getRange().isEqual(data); + for(var i = this.ranges.length; i--;)if (!this.ranges[i].isEqual(data[i])) return !1; + return !0; + }; + }).call(Selection.prototype), exports.Selection = Selection; + }), ace.define("ace/tokenizer", [ + "require", + "exports", + "module", + "ace/config" + ], function(require, exports, module) { + "use strict"; + var config = require("./config"), MAX_TOKEN_COUNT = 2000, Tokenizer = function(rules) { + for(var key in this.states = rules, this.regExps = {}, this.matchMappings = {}, this.states){ + for(var state = this.states[key], ruleRegExps = [], matchTotal = 0, mapping = this.matchMappings[key] = { + defaultToken: "text" + }, flag = "g", splitterRurles = [], i = 0; i < state.length; i++){ + var rule = state[i]; + if (rule.defaultToken && (mapping.defaultToken = rule.defaultToken), rule.caseInsensitive && (flag = "gi"), null != rule.regex) { + rule.regex instanceof RegExp && (rule.regex = rule.regex.toString().slice(1, -1)); + var adjustedregex = rule.regex, matchcount = new RegExp("(?:(" + adjustedregex + ")|(.))").exec("a").length - 2; + Array.isArray(rule.token) ? 1 == rule.token.length || 1 == matchcount ? rule.token = rule.token[0] : matchcount - 1 != rule.token.length ? (this.reportError("number of classes and regexp groups doesn't match", { + rule: rule, + groupCount: matchcount - 1 + }), rule.token = rule.token[0]) : (rule.tokenArray = rule.token, rule.token = null, rule.onMatch = this.$arrayTokens) : "function" != typeof rule.token || rule.onMatch || (matchcount > 1 ? rule.onMatch = this.$applyToken : rule.onMatch = rule.token), matchcount > 1 && (/\\\d/.test(rule.regex) ? adjustedregex = rule.regex.replace(/\\([0-9]+)/g, function(match, digit) { + return "\\" + (parseInt(digit, 10) + matchTotal + 1); + }) : (matchcount = 1, adjustedregex = this.removeCapturingGroups(rule.regex)), rule.splitRegex || "string" == typeof rule.token || splitterRurles.push(rule)), mapping[matchTotal] = i, matchTotal += matchcount, ruleRegExps.push(adjustedregex), rule.onMatch || (rule.onMatch = null); + } + } + ruleRegExps.length || (mapping[0] = 0, ruleRegExps.push("$")), splitterRurles.forEach(function(rule) { + rule.splitRegex = this.createSplitterRegexp(rule.regex, flag); + }, this), this.regExps[key] = new RegExp("(" + ruleRegExps.join(")|(") + ")|($)", flag); + } + }; + (function() { + this.$setMaxTokenCount = function(m) { + MAX_TOKEN_COUNT = 0 | m; + }, this.$applyToken = function(str) { + var values = this.splitRegex.exec(str).slice(1), types = this.token.apply(this, values); + if ("string" == typeof types) return [ + { + type: types, + value: str + } + ]; + for(var tokens = [], i = 0, l = types.length; i < l; i++)values[i] && (tokens[tokens.length] = { + type: types[i], + value: values[i] + }); + return tokens; + }, this.$arrayTokens = function(str) { + if (!str) return []; + var values = this.splitRegex.exec(str); + if (!values) return "text"; + for(var tokens = [], types = this.tokenArray, i = 0, l = types.length; i < l; i++)values[i + 1] && (tokens[tokens.length] = { + type: types[i], + value: values[i + 1] + }); + return tokens; + }, this.removeCapturingGroups = function(src) { + return src.replace(/\\.|\[(?:\\.|[^\\\]])*|\(\?[:=!<]|(\()/g, function(x, y) { + return y ? "(?:" : x; + }); + }, this.createSplitterRegexp = function(src, flag) { + if (-1 != src.indexOf("(?=")) { + var stack = 0, inChClass = !1, lastCapture = {}; + src.replace(/(\\.)|(\((?:\?[=!])?)|(\))|([\[\]])/g, function(m, esc, parenOpen, parenClose, square, index) { + return inChClass ? inChClass = "]" != square : square ? inChClass = !0 : parenClose ? (stack == lastCapture.stack && (lastCapture.end = index + 1, lastCapture.stack = -1), stack--) : parenOpen && (stack++, 1 != parenOpen.length && (lastCapture.stack = stack, lastCapture.start = index)), m; + }), null != lastCapture.end && /^\)*$/.test(src.substr(lastCapture.end)) && (src = src.substring(0, lastCapture.start) + src.substr(lastCapture.end)); + } + return "^" != src.charAt(0) && (src = "^" + src), "$" != src.charAt(src.length - 1) && (src += "$"), new RegExp(src, (flag || "").replace("g", "")); + }, this.getLineTokens = function(line, startState) { + if (startState && "string" != typeof startState) { + var stack = startState.slice(0); + "#tmp" === (startState = stack[0]) && (stack.shift(), startState = stack.shift()); + } else var stack = []; + var currentState = startState || "start", state = this.states[currentState]; + state || (currentState = "start", state = this.states[currentState]); + var mapping = this.matchMappings[currentState], re = this.regExps[currentState]; + re.lastIndex = 0; + for(var match, tokens = [], lastIndex = 0, matchAttempts = 0, token = { + type: null, + value: "" + }; match = re.exec(line);){ + var type = mapping.defaultToken, rule = null, value = match[0], index = re.lastIndex; + if (index - value.length > lastIndex) { + var skipped = line.substring(lastIndex, index - value.length); + token.type == type ? token.value += skipped : (token.type && tokens.push(token), token = { + type: type, + value: skipped + }); + } + for(var i = 0; i < match.length - 2; i++)if (void 0 !== match[i + 1]) { + type = (rule = state[mapping[i]]).onMatch ? rule.onMatch(value, currentState, stack, line) : rule.token, rule.next && (currentState = "string" == typeof rule.next ? rule.next : rule.next(currentState, stack), (state = this.states[currentState]) || (this.reportError("state doesn't exist", currentState), currentState = "start", state = this.states[currentState]), mapping = this.matchMappings[currentState], lastIndex = index, (re = this.regExps[currentState]).lastIndex = index), rule.consumeLineEnd && (lastIndex = index); + break; + } + if (value) { + if ("string" == typeof type) rule && !1 === rule.merge || token.type !== type ? (token.type && tokens.push(token), token = { + type: type, + value: value + }) : token.value += value; + else if (type) { + token.type && tokens.push(token), token = { + type: null, + value: "" + }; + for(var i = 0; i < type.length; i++)tokens.push(type[i]); + } + } + if (lastIndex == line.length) break; + if (lastIndex = index, (matchAttempts++) > MAX_TOKEN_COUNT) { + for(matchAttempts > 2 * line.length && this.reportError("infinite loop with in ace tokenizer", { + startState: startState, + line: line + }); lastIndex < line.length;)token.type && tokens.push(token), token = { + value: line.substring(lastIndex, lastIndex += 500), + type: "overflow" + }; + currentState = "start", stack = []; + break; + } + } + return token.type && tokens.push(token), stack.length > 1 && stack[0] !== currentState && stack.unshift("#tmp", currentState), { + tokens: tokens, + state: stack.length ? stack : currentState + }; + }, this.reportError = config.reportError; + }).call(Tokenizer.prototype), exports.Tokenizer = Tokenizer; + }), ace.define("ace/mode/text_highlight_rules", [ + "require", + "exports", + "module", + "ace/lib/lang" + ], function(require, exports, module) { + "use strict"; + var lang = require("../lib/lang"), TextHighlightRules = function() { + this.$rules = { + start: [ + { + token: "empty_line", + regex: '^$' + }, + { + defaultToken: "text" + } + ] + }; + }; + (function() { + this.addRules = function(rules, prefix) { + if (!prefix) { + for(var key in rules)this.$rules[key] = rules[key]; + return; + } + for(var key in rules){ + for(var state = rules[key], i = 0; i < state.length; i++){ + var rule = state[i]; + (rule.next || rule.onMatch) && ("string" == typeof rule.next && 0 !== rule.next.indexOf(prefix) && (rule.next = prefix + rule.next), rule.nextState && 0 !== rule.nextState.indexOf(prefix) && (rule.nextState = prefix + rule.nextState)); + } + this.$rules[prefix + key] = state; + } + }, this.getRules = function() { + return this.$rules; + }, this.embedRules = function(HighlightRules, prefix, escapeRules, states, append) { + var embedRules = "function" == typeof HighlightRules ? new HighlightRules().getRules() : HighlightRules; + if (states) for(var i = 0; i < states.length; i++)states[i] = prefix + states[i]; + else for(var key in states = [], embedRules)states.push(prefix + key); + if (this.addRules(embedRules, prefix), escapeRules) for(var addRules = Array.prototype[append ? "push" : "unshift"], i = 0; i < states.length; i++)addRules.apply(this.$rules[states[i]], lang.deepCopy(escapeRules)); + this.$embeds || (this.$embeds = []), this.$embeds.push(prefix); + }, this.getEmbeds = function() { + return this.$embeds; + }, this.normalizeRules = function() { + var id = 0, rules = this.$rules; + function processState(key) { + var state = rules[key]; + state.processed = !0; + for(var i = 0; i < state.length; i++){ + var rule = state[i], toInsert = null; + Array.isArray(rule) && (toInsert = rule, rule = {}), !rule.regex && rule.start && (rule.regex = rule.start, rule.next || (rule.next = []), rule.next.push({ + defaultToken: rule.token + }, { + token: rule.token + ".end", + regex: rule.end || rule.start, + next: "pop" + }), rule.token = rule.token + ".start", rule.push = !0); + var next = rule.next || rule.push; + if (next && Array.isArray(next)) { + var stateName = rule.stateName; + !stateName && ("string" != typeof (stateName = rule.token) && (stateName = stateName[0] || ""), rules[stateName] && (stateName += id++)), rules[stateName] = next, rule.next = stateName, processState(stateName); + } else "pop" == next && (rule.next = function(currentState, stack) { + return stack.shift(), stack.shift() || "start"; + }); + if (rule.push && (rule.nextState = rule.next || rule.push, rule.next = function(currentState, stack) { + return ("start" != currentState || stack.length) && stack.unshift(this.nextState, currentState), this.nextState; + }, delete rule.push), rule.rules) for(var r in rule.rules)rules[r] ? rules[r].push && rules[r].push.apply(rules[r], rule.rules[r]) : rules[r] = rule.rules[r]; + var includeName = "string" == typeof rule ? rule : rule.include; + if (includeName && (toInsert = Array.isArray(includeName) ? includeName.map(function(x) { + return rules[x]; + }) : rules[includeName]), toInsert) { + var args = [ + i, + 1 + ].concat(toInsert); + rule.noEscape && (args = args.filter(function(x) { + return !x.next; + })), state.splice.apply(state, args), i--; + } + rule.keywordMap && (rule.token = this.createKeywordMapper(rule.keywordMap, rule.defaultToken || "text", rule.caseInsensitive), delete rule.defaultToken); + } + } + Object.keys(rules).forEach(processState, this); + }, this.createKeywordMapper = function(map, defaultToken, ignoreCase, splitChar) { + var keywords = Object.create(null); + return this.$keywordList = [], Object.keys(map).forEach(function(className) { + for(var list = map[className].split(splitChar || "|"), i = list.length; i--;){ + var word = list[i]; + this.$keywordList.push(word), ignoreCase && (word = word.toLowerCase()), keywords[word] = className; + } + }, this), map = null, ignoreCase ? function(value) { + return keywords[value.toLowerCase()] || defaultToken; + } : function(value) { + return keywords[value] || defaultToken; + }; + }, this.getKeywords = function() { + return this.$keywords; + }; + }).call(TextHighlightRules.prototype), exports.TextHighlightRules = TextHighlightRules; + }), ace.define("ace/mode/behaviour", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + var Behaviour = function() { + this.$behaviours = {}; + }; + (function() { + this.add = function(name, action, callback) { + switch(void 0){ + case this.$behaviours: + this.$behaviours = {}; + case this.$behaviours[name]: + this.$behaviours[name] = {}; + } + this.$behaviours[name][action] = callback; + }, this.addBehaviours = function(behaviours) { + for(var key in behaviours)for(var action in behaviours[key])this.add(key, action, behaviours[key][action]); + }, this.remove = function(name) { + this.$behaviours && this.$behaviours[name] && delete this.$behaviours[name]; + }, this.inherit = function(mode, filter) { + if ("function" == typeof mode) var behaviours = new mode().getBehaviours(filter); + else var behaviours = mode.getBehaviours(filter); + this.addBehaviours(behaviours); + }, this.getBehaviours = function(filter) { + if (!filter) return this.$behaviours; + for(var ret = {}, i = 0; i < filter.length; i++)this.$behaviours[filter[i]] && (ret[filter[i]] = this.$behaviours[filter[i]]); + return ret; + }; + }).call(Behaviour.prototype), exports.Behaviour = Behaviour; + }), ace.define("ace/token_iterator", [ + "require", + "exports", + "module", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var Range = require("./range").Range, TokenIterator = function(session, initialRow, initialColumn) { + this.$session = session, this.$row = initialRow, this.$rowTokens = session.getTokens(initialRow); + var token = session.getTokenAt(initialRow, initialColumn); + this.$tokenIndex = token ? token.index : -1; + }; + (function() { + this.stepBackward = function() { + for(this.$tokenIndex -= 1; this.$tokenIndex < 0;){ + if (this.$row -= 1, this.$row < 0) return this.$row = 0, null; + this.$rowTokens = this.$session.getTokens(this.$row), this.$tokenIndex = this.$rowTokens.length - 1; + } + return this.$rowTokens[this.$tokenIndex]; + }, this.stepForward = function() { + var rowCount; + for(this.$tokenIndex += 1; this.$tokenIndex >= this.$rowTokens.length;){ + if (this.$row += 1, rowCount || (rowCount = this.$session.getLength()), this.$row >= rowCount) return this.$row = rowCount - 1, null; + this.$rowTokens = this.$session.getTokens(this.$row), this.$tokenIndex = 0; + } + return this.$rowTokens[this.$tokenIndex]; + }, this.getCurrentToken = function() { + return this.$rowTokens[this.$tokenIndex]; + }, this.getCurrentTokenRow = function() { + return this.$row; + }, this.getCurrentTokenColumn = function() { + var rowTokens = this.$rowTokens, tokenIndex = this.$tokenIndex, column = rowTokens[tokenIndex].start; + if (void 0 !== column) return column; + for(column = 0; tokenIndex > 0;)tokenIndex -= 1, column += rowTokens[tokenIndex].value.length; + return column; + }, this.getCurrentTokenPosition = function() { + return { + row: this.$row, + column: this.getCurrentTokenColumn() + }; + }, this.getCurrentTokenRange = function() { + var token = this.$rowTokens[this.$tokenIndex], column = this.getCurrentTokenColumn(); + return new Range(this.$row, column, this.$row, column + token.value.length); + }; + }).call(TokenIterator.prototype), exports.TokenIterator = TokenIterator; + }), ace.define("ace/mode/behaviour/cstyle", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/mode/behaviour", + "ace/token_iterator", + "ace/lib/lang" + ], function(require, exports, module) { + "use strict"; + var context, oop = require("../../lib/oop"), Behaviour = require("../behaviour").Behaviour, TokenIterator = require("../../token_iterator").TokenIterator, lang = require("../../lib/lang"), SAFE_INSERT_IN_TOKENS = [ + "text", + "paren.rparen", + "rparen", + "paren", + "punctuation.operator" + ], SAFE_INSERT_BEFORE_TOKENS = [ + "text", + "paren.rparen", + "rparen", + "paren", + "punctuation.operator", + "comment" + ], contextCache = {}, defaultQuotes = { + '"': '"', + "'": "'" + }, initContext = function(editor) { + var id = -1; + if (editor.multiSelect && (id = editor.selection.index, contextCache.rangeCount != editor.multiSelect.rangeCount && (contextCache = { + rangeCount: editor.multiSelect.rangeCount + })), contextCache[id]) return context = contextCache[id]; + context = contextCache[id] = { + autoInsertedBrackets: 0, + autoInsertedRow: -1, + autoInsertedLineEnd: "", + maybeInsertedBrackets: 0, + maybeInsertedRow: -1, + maybeInsertedLineStart: "", + maybeInsertedLineEnd: "" + }; + }, getWrapped = function(selection, selected, opening, closing) { + var rowDiff = selection.end.row - selection.start.row; + return { + text: opening + selected + closing, + selection: [ + 0, + selection.start.column + 1, + rowDiff, + selection.end.column + (rowDiff ? 0 : 1) + ] + }; + }, CstyleBehaviour = function(options) { + this.add("braces", "insertion", function(state, action, editor, session, text) { + var cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row); + if ('{' == text) { + initContext(editor); + var selection = editor.getSelectionRange(), selected = session.doc.getTextRange(selection); + if ("" !== selected && "{" !== selected && editor.getWrapBehavioursEnabled()) return getWrapped(selection, selected, '{', '}'); + if (CstyleBehaviour.isSaneInsertion(editor, session)) return /[\]\}\)]/.test(line[cursor.column]) || editor.inMultiSelectMode || options && options.braces ? (CstyleBehaviour.recordAutoInsert(editor, session, "}"), { + text: '{}', + selection: [ + 1, + 1 + ] + }) : (CstyleBehaviour.recordMaybeInsert(editor, session, "{"), { + text: '{', + selection: [ + 1, + 1 + ] + }); + } else if ('}' == text) { + initContext(editor); + var rightChar = line.substring(cursor.column, cursor.column + 1); + if ('}' == rightChar && null !== session.$findOpeningBracket('}', { + column: cursor.column + 1, + row: cursor.row + }) && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) return CstyleBehaviour.popAutoInsertedClosing(), { + text: '', + selection: [ + 1, + 1 + ] + }; + } else if ("\n" == text || "\r\n" == text) { + initContext(editor); + var closing = ""; + CstyleBehaviour.isMaybeInsertedClosing(cursor, line) && (closing = lang.stringRepeat("}", context.maybeInsertedBrackets), CstyleBehaviour.clearMaybeInsertedClosing()); + var rightChar = line.substring(cursor.column, cursor.column + 1); + if ('}' === rightChar) { + var openBracePos = session.findMatchingBracket({ + row: cursor.row, + column: cursor.column + 1 + }, '}'); + if (!openBracePos) return null; + var next_indent = this.$getIndent(session.getLine(openBracePos.row)); + } else if (closing) var next_indent = this.$getIndent(line); + else { + CstyleBehaviour.clearMaybeInsertedClosing(); + return; + } + var indent = next_indent + session.getTabString(); + return { + text: '\n' + indent + '\n' + next_indent + closing, + selection: [ + 1, + indent.length, + 1, + indent.length + ] + }; + } else CstyleBehaviour.clearMaybeInsertedClosing(); + }), this.add("braces", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && '{' == selected) { + if (initContext(editor), '}' == session.doc.getLine(range.start.row).substring(range.end.column, range.end.column + 1)) return range.end.column++, range; + context.maybeInsertedBrackets--; + } + }), this.add("parens", "insertion", function(state, action, editor, session, text) { + if ('(' == text) { + initContext(editor); + var selection = editor.getSelectionRange(), selected = session.doc.getTextRange(selection); + if ("" !== selected && editor.getWrapBehavioursEnabled()) return getWrapped(selection, selected, '(', ')'); + if (CstyleBehaviour.isSaneInsertion(editor, session)) return CstyleBehaviour.recordAutoInsert(editor, session, ")"), { + text: '()', + selection: [ + 1, + 1 + ] + }; + } else if (')' == text) { + initContext(editor); + var cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row); + if (')' == line.substring(cursor.column, cursor.column + 1) && null !== session.$findOpeningBracket(')', { + column: cursor.column + 1, + row: cursor.row + }) && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) return CstyleBehaviour.popAutoInsertedClosing(), { + text: '', + selection: [ + 1, + 1 + ] + }; + } + }), this.add("parens", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && '(' == selected && (initContext(editor), ')' == session.doc.getLine(range.start.row).substring(range.start.column + 1, range.start.column + 2))) return range.end.column++, range; + }), this.add("brackets", "insertion", function(state, action, editor, session, text) { + if ('[' == text) { + initContext(editor); + var selection = editor.getSelectionRange(), selected = session.doc.getTextRange(selection); + if ("" !== selected && editor.getWrapBehavioursEnabled()) return getWrapped(selection, selected, '[', ']'); + if (CstyleBehaviour.isSaneInsertion(editor, session)) return CstyleBehaviour.recordAutoInsert(editor, session, "]"), { + text: '[]', + selection: [ + 1, + 1 + ] + }; + } else if (']' == text) { + initContext(editor); + var cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row); + if (']' == line.substring(cursor.column, cursor.column + 1) && null !== session.$findOpeningBracket(']', { + column: cursor.column + 1, + row: cursor.row + }) && CstyleBehaviour.isAutoInsertedClosing(cursor, line, text)) return CstyleBehaviour.popAutoInsertedClosing(), { + text: '', + selection: [ + 1, + 1 + ] + }; + } + }), this.add("brackets", "deletion", function(state, action, editor, session, range) { + var selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && '[' == selected && (initContext(editor), ']' == session.doc.getLine(range.start.row).substring(range.start.column + 1, range.start.column + 2))) return range.end.column++, range; + }), this.add("string_dquotes", "insertion", function(state, action, editor, session, text) { + var quotes = session.$mode.$quotes || defaultQuotes; + if (1 == text.length && quotes[text]) { + if (this.lineCommentStart && -1 != this.lineCommentStart.indexOf(text)) return; + initContext(editor); + var quote = text, selection = editor.getSelectionRange(), selected = session.doc.getTextRange(selection); + if ("" !== selected && (1 != selected.length || !quotes[selected]) && editor.getWrapBehavioursEnabled()) return getWrapped(selection, selected, quote, quote); + if (!selected) { + var pair, cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row), leftChar = line.substring(cursor.column - 1, cursor.column), rightChar = line.substring(cursor.column, cursor.column + 1), token = session.getTokenAt(cursor.row, cursor.column), rightToken = session.getTokenAt(cursor.row, cursor.column + 1); + if ("\\" == leftChar && token && /escape/.test(token.type)) return null; + var stringBefore = token && /string|escape/.test(token.type), stringAfter = !rightToken || /string|escape/.test(rightToken.type); + if (rightChar == quote) (pair = stringBefore !== stringAfter) && /string\.end/.test(rightToken.type) && (pair = !1); + else { + if (stringBefore && !stringAfter) return null; + if (stringBefore && stringAfter) return null; + var wordRe = session.$mode.tokenRe; + wordRe.lastIndex = 0; + var isWordBefore = wordRe.test(leftChar); + wordRe.lastIndex = 0; + var isWordAfter = wordRe.test(leftChar); + if (isWordBefore || isWordAfter) return null; + if (rightChar && !/[\s;,.})\]\\]/.test(rightChar)) return null; + var charBefore = line[cursor.column - 2]; + if (leftChar == quote && (charBefore == quote || wordRe.test(charBefore))) return null; + pair = !0; + } + return { + text: pair ? quote + quote : "", + selection: [ + 1, + 1 + ] + }; + } + } + }), this.add("string_dquotes", "deletion", function(state, action, editor, session, range) { + var quotes = session.$mode.$quotes || defaultQuotes, selected = session.doc.getTextRange(range); + if (!range.isMultiLine() && quotes.hasOwnProperty(selected) && (initContext(editor), session.doc.getLine(range.start.row).substring(range.start.column + 1, range.start.column + 2) == selected)) return range.end.column++, range; + }); + }; + CstyleBehaviour.isSaneInsertion = function(editor, session) { + var cursor = editor.getCursorPosition(), iterator = new TokenIterator(session, cursor.row, cursor.column); + if (!this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) { + if (/[)}\]]/.test(editor.session.getLine(cursor.row)[cursor.column])) return !0; + var iterator2 = new TokenIterator(session, cursor.row, cursor.column + 1); + if (!this.$matchTokenType(iterator2.getCurrentToken() || "text", SAFE_INSERT_IN_TOKENS)) return !1; + } + return iterator.stepForward(), iterator.getCurrentTokenRow() !== cursor.row || this.$matchTokenType(iterator.getCurrentToken() || "text", SAFE_INSERT_BEFORE_TOKENS); + }, CstyleBehaviour.$matchTokenType = function(token, types) { + return types.indexOf(token.type || token) > -1; + }, CstyleBehaviour.recordAutoInsert = function(editor, session, bracket) { + var cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row); + this.isAutoInsertedClosing(cursor, line, context.autoInsertedLineEnd[0]) || (context.autoInsertedBrackets = 0), context.autoInsertedRow = cursor.row, context.autoInsertedLineEnd = bracket + line.substr(cursor.column), context.autoInsertedBrackets++; + }, CstyleBehaviour.recordMaybeInsert = function(editor, session, bracket) { + var cursor = editor.getCursorPosition(), line = session.doc.getLine(cursor.row); + this.isMaybeInsertedClosing(cursor, line) || (context.maybeInsertedBrackets = 0), context.maybeInsertedRow = cursor.row, context.maybeInsertedLineStart = line.substr(0, cursor.column) + bracket, context.maybeInsertedLineEnd = line.substr(cursor.column), context.maybeInsertedBrackets++; + }, CstyleBehaviour.isAutoInsertedClosing = function(cursor, line, bracket) { + return context.autoInsertedBrackets > 0 && cursor.row === context.autoInsertedRow && bracket === context.autoInsertedLineEnd[0] && line.substr(cursor.column) === context.autoInsertedLineEnd; + }, CstyleBehaviour.isMaybeInsertedClosing = function(cursor, line) { + return context.maybeInsertedBrackets > 0 && cursor.row === context.maybeInsertedRow && line.substr(cursor.column) === context.maybeInsertedLineEnd && line.substr(0, cursor.column) == context.maybeInsertedLineStart; + }, CstyleBehaviour.popAutoInsertedClosing = function() { + context.autoInsertedLineEnd = context.autoInsertedLineEnd.substr(1), context.autoInsertedBrackets--; + }, CstyleBehaviour.clearMaybeInsertedClosing = function() { + context && (context.maybeInsertedBrackets = 0, context.maybeInsertedRow = -1); + }, oop.inherits(CstyleBehaviour, Behaviour), exports.CstyleBehaviour = CstyleBehaviour; + }), ace.define("ace/unicode", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + for(var wordChars = [ + 48, + 9, + 8, + 25, + 5, + 0, + 2, + 25, + 48, + 0, + 11, + 0, + 5, + 0, + 6, + 22, + 2, + 30, + 2, + 457, + 5, + 11, + 15, + 4, + 8, + 0, + 2, + 0, + 18, + 116, + 2, + 1, + 3, + 3, + 9, + 0, + 2, + 2, + 2, + 0, + 2, + 19, + 2, + 82, + 2, + 138, + 2, + 4, + 3, + 155, + 12, + 37, + 3, + 0, + 8, + 38, + 10, + 44, + 2, + 0, + 2, + 1, + 2, + 1, + 2, + 0, + 9, + 26, + 6, + 2, + 30, + 10, + 7, + 61, + 2, + 9, + 5, + 101, + 2, + 7, + 3, + 9, + 2, + 18, + 3, + 0, + 17, + 58, + 3, + 100, + 15, + 53, + 5, + 0, + 6, + 45, + 211, + 57, + 3, + 18, + 2, + 5, + 3, + 11, + 3, + 9, + 2, + 1, + 7, + 6, + 2, + 2, + 2, + 7, + 3, + 1, + 3, + 21, + 2, + 6, + 2, + 0, + 4, + 3, + 3, + 8, + 3, + 1, + 3, + 3, + 9, + 0, + 5, + 1, + 2, + 4, + 3, + 11, + 16, + 2, + 2, + 5, + 5, + 1, + 3, + 21, + 2, + 6, + 2, + 1, + 2, + 1, + 2, + 1, + 3, + 0, + 2, + 4, + 5, + 1, + 3, + 2, + 4, + 0, + 8, + 3, + 2, + 0, + 8, + 15, + 12, + 2, + 2, + 8, + 2, + 2, + 2, + 21, + 2, + 6, + 2, + 1, + 2, + 4, + 3, + 9, + 2, + 2, + 2, + 2, + 3, + 0, + 16, + 3, + 3, + 9, + 18, + 2, + 2, + 7, + 3, + 1, + 3, + 21, + 2, + 6, + 2, + 1, + 2, + 4, + 3, + 8, + 3, + 1, + 3, + 2, + 9, + 1, + 5, + 1, + 2, + 4, + 3, + 9, + 2, + 0, + 17, + 1, + 2, + 5, + 4, + 2, + 2, + 3, + 4, + 1, + 2, + 0, + 2, + 1, + 4, + 1, + 4, + 2, + 4, + 11, + 5, + 4, + 4, + 2, + 2, + 3, + 3, + 0, + 7, + 0, + 15, + 9, + 18, + 2, + 2, + 7, + 2, + 2, + 2, + 22, + 2, + 9, + 2, + 4, + 4, + 7, + 2, + 2, + 2, + 3, + 8, + 1, + 2, + 1, + 7, + 3, + 3, + 9, + 19, + 1, + 2, + 7, + 2, + 2, + 2, + 22, + 2, + 9, + 2, + 4, + 3, + 8, + 2, + 2, + 2, + 3, + 8, + 1, + 8, + 0, + 2, + 3, + 3, + 9, + 19, + 1, + 2, + 7, + 2, + 2, + 2, + 22, + 2, + 15, + 4, + 7, + 2, + 2, + 2, + 3, + 10, + 0, + 9, + 3, + 3, + 9, + 11, + 5, + 3, + 1, + 2, + 17, + 4, + 23, + 2, + 8, + 2, + 0, + 3, + 6, + 4, + 0, + 5, + 5, + 2, + 0, + 2, + 7, + 19, + 1, + 14, + 57, + 6, + 14, + 2, + 9, + 40, + 1, + 2, + 0, + 3, + 1, + 2, + 0, + 3, + 0, + 7, + 3, + 2, + 6, + 2, + 2, + 2, + 0, + 2, + 0, + 3, + 1, + 2, + 12, + 2, + 2, + 3, + 4, + 2, + 0, + 2, + 5, + 3, + 9, + 3, + 1, + 35, + 0, + 24, + 1, + 7, + 9, + 12, + 0, + 2, + 0, + 2, + 0, + 5, + 9, + 2, + 35, + 5, + 19, + 2, + 5, + 5, + 7, + 2, + 35, + 10, + 0, + 58, + 73, + 7, + 77, + 3, + 37, + 11, + 42, + 2, + 0, + 4, + 328, + 2, + 3, + 3, + 6, + 2, + 0, + 2, + 3, + 3, + 40, + 2, + 3, + 3, + 32, + 2, + 3, + 3, + 6, + 2, + 0, + 2, + 3, + 3, + 14, + 2, + 56, + 2, + 3, + 3, + 66, + 5, + 0, + 33, + 15, + 17, + 84, + 13, + 619, + 3, + 16, + 2, + 25, + 6, + 74, + 22, + 12, + 2, + 6, + 12, + 20, + 12, + 19, + 13, + 12, + 2, + 2, + 2, + 1, + 13, + 51, + 3, + 29, + 4, + 0, + 5, + 1, + 3, + 9, + 34, + 2, + 3, + 9, + 7, + 87, + 9, + 42, + 6, + 69, + 11, + 28, + 4, + 11, + 5, + 11, + 11, + 39, + 3, + 4, + 12, + 43, + 5, + 25, + 7, + 10, + 38, + 27, + 5, + 62, + 2, + 28, + 3, + 10, + 7, + 9, + 14, + 0, + 89, + 75, + 5, + 9, + 18, + 8, + 13, + 42, + 4, + 11, + 71, + 55, + 9, + 9, + 4, + 48, + 83, + 2, + 2, + 30, + 14, + 230, + 23, + 280, + 3, + 5, + 3, + 37, + 3, + 5, + 3, + 7, + 2, + 0, + 2, + 0, + 2, + 0, + 2, + 30, + 3, + 52, + 2, + 6, + 2, + 0, + 4, + 2, + 2, + 6, + 4, + 3, + 3, + 5, + 5, + 12, + 6, + 2, + 2, + 6, + 67, + 1, + 20, + 0, + 29, + 0, + 14, + 0, + 17, + 4, + 60, + 12, + 5, + 0, + 4, + 11, + 18, + 0, + 5, + 0, + 3, + 9, + 2, + 0, + 4, + 4, + 7, + 0, + 2, + 0, + 2, + 0, + 2, + 3, + 2, + 10, + 3, + 3, + 6, + 4, + 5, + 0, + 53, + 1, + 2684, + 46, + 2, + 46, + 2, + 132, + 7, + 6, + 15, + 37, + 11, + 53, + 10, + 0, + 17, + 22, + 10, + 6, + 2, + 6, + 2, + 6, + 2, + 6, + 2, + 6, + 2, + 6, + 2, + 6, + 2, + 6, + 2, + 31, + 48, + 0, + 470, + 1, + 36, + 5, + 2, + 4, + 6, + 1, + 5, + 85, + 3, + 1, + 3, + 2, + 2, + 89, + 2, + 3, + 6, + 40, + 4, + 93, + 18, + 23, + 57, + 15, + 513, + 6581, + 75, + 20939, + 53, + 1164, + 68, + 45, + 3, + 268, + 4, + 27, + 21, + 31, + 3, + 13, + 13, + 1, + 2, + 24, + 9, + 69, + 11, + 1, + 38, + 8, + 3, + 102, + 3, + 1, + 111, + 44, + 25, + 51, + 13, + 68, + 12, + 9, + 7, + 23, + 4, + 0, + 5, + 45, + 3, + 35, + 13, + 28, + 4, + 64, + 15, + 10, + 39, + 54, + 10, + 13, + 3, + 9, + 7, + 22, + 4, + 1, + 5, + 66, + 25, + 2, + 227, + 42, + 2, + 1, + 3, + 9, + 7, + 11171, + 13, + 22, + 5, + 48, + 8453, + 301, + 3, + 61, + 3, + 105, + 39, + 6, + 13, + 4, + 6, + 11, + 2, + 12, + 2, + 4, + 2, + 0, + 2, + 1, + 2, + 1, + 2, + 107, + 34, + 362, + 19, + 63, + 3, + 53, + 41, + 11, + 5, + 15, + 17, + 6, + 13, + 1, + 25, + 2, + 33, + 4, + 2, + 134, + 20, + 9, + 8, + 25, + 5, + 0, + 2, + 25, + 12, + 88, + 4, + 5, + 3, + 5, + 3, + 5, + 3, + 2 + ], code = 0, str = [], i = 0; i < wordChars.length; i += 2)str.push(code += wordChars[i]), wordChars[i + 1] && str.push(45, code += wordChars[i + 1]); + exports.wordChars = String.fromCharCode.apply(null, str); + }), ace.define("ace/mode/text", [ + "require", + "exports", + "module", + "ace/config", + "ace/tokenizer", + "ace/mode/text_highlight_rules", + "ace/mode/behaviour/cstyle", + "ace/unicode", + "ace/lib/lang", + "ace/token_iterator", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var config = require("../config"), Tokenizer = require("../tokenizer").Tokenizer, TextHighlightRules = require("./text_highlight_rules").TextHighlightRules, CstyleBehaviour = require("./behaviour/cstyle").CstyleBehaviour, unicode = require("../unicode"), lang = require("../lib/lang"), TokenIterator = require("../token_iterator").TokenIterator, Range = require("../range").Range, Mode1 = function() { + this.HighlightRules = TextHighlightRules; + }; + (function() { + this.$defaultBehaviour = new CstyleBehaviour(), this.tokenRe = new RegExp("^[" + unicode.wordChars + "\\$_]+", "g"), this.nonTokenRe = new RegExp("^(?:[^" + unicode.wordChars + "\\$_]|\\s])+", "g"), this.getTokenizer = function() { + return this.$tokenizer || (this.$highlightRules = this.$highlightRules || new this.HighlightRules(this.$highlightRuleConfig), this.$tokenizer = new Tokenizer(this.$highlightRules.getRules())), this.$tokenizer; + }, this.lineCommentStart = "", this.blockComment = "", this.toggleCommentLines = function(state, session, startRow, endRow) { + var doc = session.doc, ignoreBlankLines = !0, shouldRemove = !0, minIndent = 1 / 0, tabSize = session.getTabSize(), insertAtTabStop = !1; + if (this.lineCommentStart) { + if (Array.isArray(this.lineCommentStart)) var regexpStart = this.lineCommentStart.map(lang.escapeRegExp).join("|"), lineCommentStart = this.lineCommentStart[0]; + else var regexpStart = lang.escapeRegExp(this.lineCommentStart), lineCommentStart = this.lineCommentStart; + regexpStart = new RegExp("^(\\s*)(?:" + regexpStart + ") ?"), insertAtTabStop = session.getUseSoftTabs(); + var uncomment = function(line, i) { + var m = line.match(regexpStart); + if (m) { + var start = m[1].length, end = m[0].length; + !shouldInsertSpace(line, start, end) && " " == m[0][end - 1] && end--, doc.removeInLine(i, start, end); + } + }, commentWithSpace = lineCommentStart + " ", comment = function(line, i) { + (!ignoreBlankLines || /\S/.test(line)) && (shouldInsertSpace(line, minIndent, minIndent) ? doc.insertInLine({ + row: i, + column: minIndent + }, commentWithSpace) : doc.insertInLine({ + row: i, + column: minIndent + }, lineCommentStart)); + }, testRemove = function(line, i) { + return regexpStart.test(line); + }, shouldInsertSpace = function(line, before, after) { + for(var spaces = 0; (before--) && " " == line.charAt(before);)spaces++; + if (spaces % tabSize != 0) return !1; + for(var spaces = 0; " " == line.charAt(after++);)spaces++; + return tabSize > 2 ? spaces % tabSize != tabSize - 1 : spaces % tabSize == 0; + }; + } else { + if (!this.blockComment) return !1; + var lineCommentStart = this.blockComment.start, lineCommentEnd = this.blockComment.end, regexpStart = new RegExp("^(\\s*)(?:" + lang.escapeRegExp(lineCommentStart) + ")"), regexpEnd = new RegExp("(?:" + lang.escapeRegExp(lineCommentEnd) + ")\\s*$"), comment = function(line, i) { + !testRemove(line, i) && (!ignoreBlankLines || /\S/.test(line)) && (doc.insertInLine({ + row: i, + column: line.length + }, lineCommentEnd), doc.insertInLine({ + row: i, + column: minIndent + }, lineCommentStart)); + }, uncomment = function(line, i) { + var m; + (m = line.match(regexpEnd)) && doc.removeInLine(i, line.length - m[0].length, line.length), (m = line.match(regexpStart)) && doc.removeInLine(i, m[1].length, m[0].length); + }, testRemove = function(line, row) { + if (regexpStart.test(line)) return !0; + for(var tokens = session.getTokens(row), i = 0; i < tokens.length; i++)if ("comment" === tokens[i].type) return !0; + }; + } + function iter(fun) { + for(var i = startRow; i <= endRow; i++)fun(doc.getLine(i), i); + } + var minEmptyLength = 1 / 0; + iter(function(line, i) { + var indent = line.search(/\S/); + -1 !== indent ? (indent < minIndent && (minIndent = indent), shouldRemove && !testRemove(line, i) && (shouldRemove = !1)) : minEmptyLength > line.length && (minEmptyLength = line.length); + }), minIndent == 1 / 0 && (minIndent = minEmptyLength, ignoreBlankLines = !1, shouldRemove = !1), insertAtTabStop && minIndent % tabSize != 0 && (minIndent = Math.floor(minIndent / tabSize) * tabSize), iter(shouldRemove ? uncomment : comment); + }, this.toggleBlockComment = function(state, session, range, cursor) { + var comment = this.blockComment; + if (comment) { + !comment.start && comment[0] && (comment = comment[0]); + var iterator = new TokenIterator(session, cursor.row, cursor.column), token = iterator.getCurrentToken(); + session.selection; + var initialRange = session.selection.toOrientedRange(); + if (token && /comment/.test(token.type)) { + for(; token && /comment/.test(token.type);){ + var startRow, colDiff, startRange, endRange, i = token.value.indexOf(comment.start); + if (-1 != i) { + var row = iterator.getCurrentTokenRow(), column = iterator.getCurrentTokenColumn() + i; + startRange = new Range(row, column, row, column + comment.start.length); + break; + } + token = iterator.stepBackward(); + } + for(var iterator = new TokenIterator(session, cursor.row, cursor.column), token = iterator.getCurrentToken(); token && /comment/.test(token.type);){ + var i = token.value.indexOf(comment.end); + if (-1 != i) { + var row = iterator.getCurrentTokenRow(), column = iterator.getCurrentTokenColumn() + i; + endRange = new Range(row, column, row, column + comment.end.length); + break; + } + token = iterator.stepForward(); + } + endRange && session.remove(endRange), startRange && (session.remove(startRange), startRow = startRange.start.row, colDiff = -comment.start.length); + } else colDiff = comment.start.length, startRow = range.start.row, session.insert(range.end, comment.end), session.insert(range.start, comment.start); + initialRange.start.row == startRow && (initialRange.start.column += colDiff), initialRange.end.row == startRow && (initialRange.end.column += colDiff), session.selection.fromOrientedRange(initialRange); + } + }, this.getNextLineIndent = function(state, line, tab) { + return this.$getIndent(line); + }, this.checkOutdent = function(state, line, input) { + return !1; + }, this.autoOutdent = function(state, doc, row) {}, this.$getIndent = function(line) { + return line.match(/^\s*/)[0]; + }, this.createWorker = function(session) { + return null; + }, this.createModeDelegates = function(mapping) { + for(var i in this.$embeds = [], this.$modes = {}, mapping)if (mapping[i]) { + var Mode = mapping[i], id = Mode.prototype.$id, mode = config.$modes[id]; + mode || (config.$modes[id] = mode = new Mode()), config.$modes[i] || (config.$modes[i] = mode), this.$embeds.push(i), this.$modes[i] = mode; + } + for(var delegations = [ + "toggleBlockComment", + "toggleCommentLines", + "getNextLineIndent", + "checkOutdent", + "autoOutdent", + "transformAction", + "getCompletions" + ], i = 0; i < delegations.length; i++)!function(scope) { + var functionName = delegations[i], defaultHandler = scope[functionName]; + scope[delegations[i]] = function() { + return this.$delegator(functionName, arguments, defaultHandler); + }; + }(this); + }, this.$delegator = function(method, args, defaultHandler) { + var state = args[0] || "start"; + if ("string" != typeof state) { + if (Array.isArray(state[2])) { + var language = state[2][state[2].length - 1], mode = this.$modes[language]; + if (mode) return mode[method].apply(mode, [ + state[1] + ].concat([].slice.call(args, 1))); + } + state = state[0] || "start"; + } + for(var i = 0; i < this.$embeds.length; i++)if (this.$modes[this.$embeds[i]]) { + var split = state.split(this.$embeds[i]); + if (!split[0] && split[1]) { + args[0] = split[1]; + var mode = this.$modes[this.$embeds[i]]; + return mode[method].apply(mode, args); + } + } + var ret = defaultHandler.apply(this, args); + return defaultHandler ? ret : void 0; + }, this.transformAction = function(state, action, editor, session, param) { + if (this.$behaviour) { + var behaviours = this.$behaviour.getBehaviours(); + for(var key in behaviours)if (behaviours[key][action]) { + var ret = behaviours[key][action].apply(this, arguments); + if (ret) return ret; + } + } + }, this.getKeywords = function(append) { + if (!this.completionKeywords) { + var rules = this.$tokenizer.rules, completionKeywords = []; + for(var rule in rules)for(var ruleItr = rules[rule], r = 0, l = ruleItr.length; r < l; r++)if ("string" == typeof ruleItr[r].token) /keyword|support|storage/.test(ruleItr[r].token) && completionKeywords.push(ruleItr[r].regex); + else if ("object" == typeof ruleItr[r].token) { + for(var a = 0, aLength = ruleItr[r].token.length; a < aLength; a++)if (/keyword|support|storage/.test(ruleItr[r].token[a])) { + var rule = ruleItr[r].regex.match(/\(.+?\)/g)[a]; + completionKeywords.push(rule.substr(1, rule.length - 2)); + } + } + this.completionKeywords = completionKeywords; + } + return append ? completionKeywords.concat(this.$keywordList || []) : this.$keywordList; + }, this.$createKeywordList = function() { + return this.$highlightRules || this.getTokenizer(), this.$keywordList = this.$highlightRules.$keywordList || []; + }, this.getCompletions = function(state, session, pos, prefix) { + return (this.$keywordList || this.$createKeywordList()).map(function(word) { + return { + name: word, + value: word, + score: 0, + meta: "keyword" + }; + }); + }, this.$id = "ace/mode/text"; + }).call(Mode1.prototype), exports.Mode = Mode1; + }), ace.define("ace/apply_delta", [ + "require", + "exports", + "module" + ], function(require, exports, module) { + "use strict"; + exports.applyDelta = function(docLines, delta, doNotValidate) { + var row = delta.start.row, startColumn = delta.start.column, line = docLines[row] || ""; + switch(delta.action){ + case "insert": + if (1 === delta.lines.length) docLines[row] = line.substring(0, startColumn) + delta.lines[0] + line.substring(startColumn); + else { + var args = [ + row, + 1 + ].concat(delta.lines); + docLines.splice.apply(docLines, args), docLines[row] = line.substring(0, startColumn) + docLines[row], docLines[row + delta.lines.length - 1] += line.substring(startColumn); + } + break; + case "remove": + var endColumn = delta.end.column, endRow = delta.end.row; + row === endRow ? docLines[row] = line.substring(0, startColumn) + line.substring(endColumn) : docLines.splice(row, endRow - row + 1, line.substring(0, startColumn) + docLines[endRow].substring(endColumn)); + break; + } + }; + }), ace.define("ace/anchor", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), EventEmitter = require("./lib/event_emitter").EventEmitter, Anchor = exports.Anchor = function(doc, row, column) { + this.$onChange = this.onChange.bind(this), this.attach(doc), void 0 === column ? this.setPosition(row.row, row.column) : this.setPosition(row, column); + }; + (function() { + function $pointsInOrder(point1, point2, equalPointsInOrder) { + var bColIsAfter = equalPointsInOrder ? point1.column <= point2.column : point1.column < point2.column; + return point1.row < point2.row || point1.row == point2.row && bColIsAfter; + } + oop.implement(this, EventEmitter), this.getPosition = function() { + return this.$clipPositionToDocument(this.row, this.column); + }, this.getDocument = function() { + return this.document; + }, this.$insertRight = !1, this.onChange = function(delta) { + if ((delta.start.row != delta.end.row || delta.start.row == this.row) && !(delta.start.row > this.row)) { + var delta1, point, moveIfEqual, deltaIsInsert, deltaRowShift, deltaColShift, deltaStart, deltaEnd, point3 = (delta1 = delta, point = { + row: this.row, + column: this.column + }, moveIfEqual = this.$insertRight, deltaRowShift = ((deltaIsInsert = "insert" == delta1.action) ? 1 : -1) * (delta1.end.row - delta1.start.row), deltaColShift = (deltaIsInsert ? 1 : -1) * (delta1.end.column - delta1.start.column), deltaStart = delta1.start, deltaEnd = deltaIsInsert ? deltaStart : delta1.end, $pointsInOrder(point, deltaStart, moveIfEqual) ? { + row: point.row, + column: point.column + } : $pointsInOrder(deltaEnd, point, !moveIfEqual) ? { + row: point.row + deltaRowShift, + column: point.column + (point.row == deltaEnd.row ? deltaColShift : 0) + } : { + row: deltaStart.row, + column: deltaStart.column + }); + this.setPosition(point3.row, point3.column, !0); + } + }, this.setPosition = function(row, column, noClip) { + if (pos = noClip ? { + row: row, + column: column + } : this.$clipPositionToDocument(row, column), this.row != pos.row || this.column != pos.column) { + var pos, old = { + row: this.row, + column: this.column + }; + this.row = pos.row, this.column = pos.column, this._signal("change", { + old: old, + value: pos + }); + } + }, this.detach = function() { + this.document.off("change", this.$onChange); + }, this.attach = function(doc) { + this.document = doc || this.document, this.document.on("change", this.$onChange); + }, this.$clipPositionToDocument = function(row, column) { + var pos = {}; + return row >= this.document.getLength() ? (pos.row = Math.max(0, this.document.getLength() - 1), pos.column = this.document.getLine(pos.row).length) : row < 0 ? (pos.row = 0, pos.column = 0) : (pos.row = row, pos.column = Math.min(this.document.getLine(pos.row).length, Math.max(0, column))), column < 0 && (pos.column = 0), pos; + }; + }).call(Anchor.prototype); + }), ace.define("ace/document", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/apply_delta", + "ace/lib/event_emitter", + "ace/range", + "ace/anchor" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), applyDelta = require("./apply_delta").applyDelta, EventEmitter = require("./lib/event_emitter").EventEmitter, Range = require("./range").Range, Anchor = require("./anchor").Anchor, Document = function(textOrLines) { + this.$lines = [ + "" + ], 0 === textOrLines.length ? this.$lines = [ + "" + ] : Array.isArray(textOrLines) ? this.insertMergedLines({ + row: 0, + column: 0 + }, textOrLines) : this.insert({ + row: 0, + column: 0 + }, textOrLines); + }; + (function() { + oop.implement(this, EventEmitter), this.setValue = function(text) { + var len = this.getLength() - 1; + this.remove(new Range(0, 0, len, this.getLine(len).length)), this.insert({ + row: 0, + column: 0 + }, text); + }, this.getValue = function() { + return this.getAllLines().join(this.getNewLineCharacter()); + }, this.createAnchor = function(row, column) { + return new Anchor(this, row, column); + }, 0 === "aaa".split(/a/).length ? this.$split = function(text) { + return text.replace(/\r\n|\r/g, "\n").split("\n"); + } : this.$split = function(text) { + return text.split(/\r\n|\r|\n/); + }, this.$detectNewLine = function(text) { + var match = text.match(/^.*?(\r\n|\r|\n)/m); + this.$autoNewLine = match ? match[1] : "\n", this._signal("changeNewLineMode"); + }, this.getNewLineCharacter = function() { + switch(this.$newLineMode){ + case "windows": + return "\r\n"; + case "unix": + return "\n"; + default: + return this.$autoNewLine || "\n"; + } + }, this.$autoNewLine = "", this.$newLineMode = "auto", this.setNewLineMode = function(newLineMode) { + this.$newLineMode !== newLineMode && (this.$newLineMode = newLineMode, this._signal("changeNewLineMode")); + }, this.getNewLineMode = function() { + return this.$newLineMode; + }, this.isNewLine = function(text) { + return "\r\n" == text || "\r" == text || "\n" == text; + }, this.getLine = function(row) { + return this.$lines[row] || ""; + }, this.getLines = function(firstRow, lastRow) { + return this.$lines.slice(firstRow, lastRow + 1); + }, this.getAllLines = function() { + return this.getLines(0, this.getLength()); + }, this.getLength = function() { + return this.$lines.length; + }, this.getTextRange = function(range) { + return this.getLinesForRange(range).join(this.getNewLineCharacter()); + }, this.getLinesForRange = function(range) { + var lines; + if (range.start.row === range.end.row) lines = [ + this.getLine(range.start.row).substring(range.start.column, range.end.column) + ]; + else { + (lines = this.getLines(range.start.row, range.end.row))[0] = (lines[0] || "").substring(range.start.column); + var l = lines.length - 1; + range.end.row - range.start.row == l && (lines[l] = lines[l].substring(0, range.end.column)); + } + return lines; + }, this.insertLines = function(row, lines) { + return console.warn("Use of document.insertLines is deprecated. Use the insertFullLines method instead."), this.insertFullLines(row, lines); + }, this.removeLines = function(firstRow, lastRow) { + return console.warn("Use of document.removeLines is deprecated. Use the removeFullLines method instead."), this.removeFullLines(firstRow, lastRow); + }, this.insertNewLine = function(position) { + return console.warn("Use of document.insertNewLine is deprecated. Use insertMergedLines(position, ['', '']) instead."), this.insertMergedLines(position, [ + "", + "" + ]); + }, this.insert = function(position, text) { + return 1 >= this.getLength() && this.$detectNewLine(text), this.insertMergedLines(position, this.$split(text)); + }, this.insertInLine = function(position, text) { + var start = this.clippedPos(position.row, position.column), end = this.pos(position.row, position.column + text.length); + return this.applyDelta({ + start: start, + end: end, + action: "insert", + lines: [ + text + ] + }, !0), this.clonePos(end); + }, this.clippedPos = function(row, column) { + var length = this.getLength(); + void 0 === row ? row = length : row < 0 ? row = 0 : row >= length && (row = length - 1, column = void 0); + var line = this.getLine(row); + return void 0 == column && (column = line.length), { + row: row, + column: column = Math.min(Math.max(column, 0), line.length) + }; + }, this.clonePos = function(pos) { + return { + row: pos.row, + column: pos.column + }; + }, this.pos = function(row, column) { + return { + row: row, + column: column + }; + }, this.$clipPosition = function(position) { + var length = this.getLength(); + return position.row >= length ? (position.row = Math.max(0, length - 1), position.column = this.getLine(length - 1).length) : (position.row = Math.max(0, position.row), position.column = Math.min(Math.max(position.column, 0), this.getLine(position.row).length)), position; + }, this.insertFullLines = function(row, lines) { + row = Math.min(Math.max(row, 0), this.getLength()); + var column = 0; + row < this.getLength() ? (lines = lines.concat([ + "" + ]), column = 0) : (lines = [ + "" + ].concat(lines), row--, column = this.$lines[row].length), this.insertMergedLines({ + row: row, + column: column + }, lines); + }, this.insertMergedLines = function(position, lines) { + var start = this.clippedPos(position.row, position.column), end = { + row: start.row + lines.length - 1, + column: (1 == lines.length ? start.column : 0) + lines[lines.length - 1].length + }; + return this.applyDelta({ + start: start, + end: end, + action: "insert", + lines: lines + }), this.clonePos(end); + }, this.remove = function(range) { + var start = this.clippedPos(range.start.row, range.start.column), end = this.clippedPos(range.end.row, range.end.column); + return this.applyDelta({ + start: start, + end: end, + action: "remove", + lines: this.getLinesForRange({ + start: start, + end: end + }) + }), this.clonePos(start); + }, this.removeInLine = function(row, startColumn, endColumn) { + var start = this.clippedPos(row, startColumn), end = this.clippedPos(row, endColumn); + return this.applyDelta({ + start: start, + end: end, + action: "remove", + lines: this.getLinesForRange({ + start: start, + end: end + }) + }, !0), this.clonePos(start); + }, this.removeFullLines = function(firstRow, lastRow) { + firstRow = Math.min(Math.max(0, firstRow), this.getLength() - 1); + var deleteFirstNewLine = (lastRow = Math.min(Math.max(0, lastRow), this.getLength() - 1)) == this.getLength() - 1 && firstRow > 0, deleteLastNewLine = lastRow < this.getLength() - 1, startRow = deleteFirstNewLine ? firstRow - 1 : firstRow, startCol = deleteFirstNewLine ? this.getLine(startRow).length : 0, endRow = deleteLastNewLine ? lastRow + 1 : lastRow, endCol = deleteLastNewLine ? 0 : this.getLine(endRow).length, range = new Range(startRow, startCol, endRow, endCol), deletedLines = this.$lines.slice(firstRow, lastRow + 1); + return this.applyDelta({ + start: range.start, + end: range.end, + action: "remove", + lines: this.getLinesForRange(range) + }), deletedLines; + }, this.removeNewLine = function(row) { + row < this.getLength() - 1 && row >= 0 && this.applyDelta({ + start: this.pos(row, this.getLine(row).length), + end: this.pos(row + 1, 0), + action: "remove", + lines: [ + "", + "" + ] + }); + }, this.replace = function(range, text) { + return (range instanceof Range || (range = Range.fromPoints(range.start, range.end)), 0 === text.length && range.isEmpty()) ? range.start : text == this.getTextRange(range) ? range.end : (this.remove(range), text ? this.insert(range.start, text) : range.start); + }, this.applyDeltas = function(deltas) { + for(var i = 0; i < deltas.length; i++)this.applyDelta(deltas[i]); + }, this.revertDeltas = function(deltas) { + for(var i = deltas.length - 1; i >= 0; i--)this.revertDelta(deltas[i]); + }, this.applyDelta = function(delta, doNotValidate) { + var isInsert = "insert" == delta.action; + (isInsert ? !(delta.lines.length <= 1) || delta.lines[0] : Range.comparePoints(delta.start, delta.end)) && (isInsert && delta.lines.length > 20000 ? this.$splitAndapplyLargeDelta(delta, 20000) : (applyDelta(this.$lines, delta, doNotValidate), this._signal("change", delta))); + }, this.$safeApplyDelta = function(delta) { + var docLength = this.$lines.length; + ("remove" == delta.action && delta.start.row < docLength && delta.end.row < docLength || "insert" == delta.action && delta.start.row <= docLength) && this.applyDelta(delta); + }, this.$splitAndapplyLargeDelta = function(delta, MAX) { + for(var lines = delta.lines, l = lines.length - MAX + 1, row = delta.start.row, column = delta.start.column, from = 0, to = 0; from < l; from = to){ + to += MAX - 1; + var chunk = lines.slice(from, to); + chunk.push(""), this.applyDelta({ + start: this.pos(row + from, column), + end: this.pos(row + to, column = 0), + action: delta.action, + lines: chunk + }, !0); + } + delta.lines = lines.slice(from), delta.start.row = row + from, delta.start.column = column, this.applyDelta(delta, !0); + }, this.revertDelta = function(delta) { + this.$safeApplyDelta({ + start: this.clonePos(delta.start), + end: this.clonePos(delta.end), + action: "insert" == delta.action ? "remove" : "insert", + lines: delta.lines.slice() + }); + }, this.indexToPosition = function(index, startRow) { + for(var lines = this.$lines || this.getAllLines(), newlineLength = this.getNewLineCharacter().length, i = startRow || 0, l = lines.length; i < l; i++)if ((index -= lines[i].length + newlineLength) < 0) return { + row: i, + column: index + lines[i].length + newlineLength + }; + return { + row: l - 1, + column: index + lines[l - 1].length + newlineLength + }; + }, this.positionToIndex = function(pos, startRow) { + for(var lines = this.$lines || this.getAllLines(), newlineLength = this.getNewLineCharacter().length, index = 0, row = Math.min(pos.row, lines.length), i = startRow || 0; i < row; ++i)index += lines[i].length + newlineLength; + return index + pos.column; + }; + }).call(Document.prototype), exports.Document = Document; + }), ace.define("ace/background_tokenizer", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), EventEmitter = require("./lib/event_emitter").EventEmitter, BackgroundTokenizer = function(tokenizer, editor) { + this.running = !1, this.lines = [], this.states = [], this.currentLine = 0, this.tokenizer = tokenizer; + var self = this; + this.$worker = function() { + if (self.running) { + for(var workerStart = new Date(), currentLine = self.currentLine, endLine = -1, doc = self.doc, startLine = currentLine; self.lines[currentLine];)currentLine++; + var len = doc.getLength(), processedLines = 0; + for(self.running = !1; currentLine < len;){ + self.$tokenizeRow(currentLine), endLine = currentLine; + do currentLine++; + while (self.lines[currentLine]) + if (processedLines++, processedLines % 5 == 0 && new Date() - workerStart > 20) { + self.running = setTimeout(self.$worker, 20); + break; + } + } + self.currentLine = currentLine, -1 == endLine && (endLine = currentLine), startLine <= endLine && self.fireUpdateEvent(startLine, endLine); + } + }; + }; + (function() { + oop.implement(this, EventEmitter), this.setTokenizer = function(tokenizer) { + this.tokenizer = tokenizer, this.lines = [], this.states = [], this.start(0); + }, this.setDocument = function(doc) { + this.doc = doc, this.lines = [], this.states = [], this.stop(); + }, this.fireUpdateEvent = function(firstRow, lastRow) { + this._signal("update", { + data: { + first: firstRow, + last: lastRow + } + }); + }, this.start = function(startRow) { + this.currentLine = Math.min(startRow || 0, this.currentLine, this.doc.getLength()), this.lines.splice(this.currentLine, this.lines.length), this.states.splice(this.currentLine, this.states.length), this.stop(), this.running = setTimeout(this.$worker, 700); + }, this.scheduleStart = function() { + this.running || (this.running = setTimeout(this.$worker, 700)); + }, this.$updateOnChange = function(delta) { + var startRow = delta.start.row, len = delta.end.row - startRow; + if (0 === len) this.lines[startRow] = null; + else if ("remove" == delta.action) this.lines.splice(startRow, len + 1, null), this.states.splice(startRow, len + 1, null); + else { + var args = Array(len + 1); + args.unshift(startRow, 1), this.lines.splice.apply(this.lines, args), this.states.splice.apply(this.states, args); + } + this.currentLine = Math.min(startRow, this.currentLine, this.doc.getLength()), this.stop(); + }, this.stop = function() { + this.running && clearTimeout(this.running), this.running = !1; + }, this.getTokens = function(row) { + return this.lines[row] || this.$tokenizeRow(row); + }, this.getState = function(row) { + return this.currentLine == row && this.$tokenizeRow(row), this.states[row] || "start"; + }, this.$tokenizeRow = function(row) { + var line = this.doc.getLine(row), state = this.states[row - 1], data = this.tokenizer.getLineTokens(line, state, row); + return this.states[row] + "" != data.state + "" ? (this.states[row] = data.state, this.lines[row + 1] = null, this.currentLine > row + 1 && (this.currentLine = row + 1)) : this.currentLine == row && (this.currentLine = row + 1), this.lines[row] = data.tokens; + }; + }).call(BackgroundTokenizer.prototype), exports.BackgroundTokenizer = BackgroundTokenizer; + }), ace.define("ace/search_highlight", [ + "require", + "exports", + "module", + "ace/lib/lang", + "ace/lib/oop", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var lang = require("./lib/lang"); + require("./lib/oop"); + var Range = require("./range").Range, SearchHighlight = function(regExp, clazz, type) { + this.setRegexp(regExp), this.clazz = clazz, this.type = type || "text"; + }; + (function() { + this.MAX_RANGES = 500, this.setRegexp = function(regExp) { + this.regExp + "" != regExp + "" && (this.regExp = regExp, this.cache = []); + }, this.update = function(html, markerLayer, session, config) { + if (this.regExp) for(var start = config.firstRow, end = config.lastRow, i = start; i <= end; i++){ + var ranges = this.cache[i]; + null == ranges && ((ranges = lang.getMatchOffsets(session.getLine(i), this.regExp)).length > this.MAX_RANGES && (ranges = ranges.slice(0, this.MAX_RANGES)), ranges = ranges.map(function(match) { + return new Range(i, match.offset, i, match.offset + match.length); + }), this.cache[i] = ranges.length ? ranges : ""); + for(var j = ranges.length; j--;)markerLayer.drawSingleLineMarker(html, ranges[j].toScreenRange(session), this.clazz, config); + } + }; + }).call(SearchHighlight.prototype), exports.SearchHighlight = SearchHighlight; + }), ace.define("ace/edit_session/fold_line", [ + "require", + "exports", + "module", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var Range = require("../range").Range; + function FoldLine(foldData, folds) { + this.foldData = foldData, Array.isArray(folds) ? this.folds = folds : folds = this.folds = [ + folds + ]; + var last = folds[folds.length - 1]; + this.range = new Range(folds[0].start.row, folds[0].start.column, last.end.row, last.end.column), this.start = this.range.start, this.end = this.range.end, this.folds.forEach(function(fold) { + fold.setFoldLine(this); + }, this); + } + (function() { + this.shiftRow = function(shift) { + this.start.row += shift, this.end.row += shift, this.folds.forEach(function(fold) { + fold.start.row += shift, fold.end.row += shift; + }); + }, this.addFold = function(fold) { + if (fold.sameRow) { + if (fold.start.row < this.startRow || fold.endRow > this.endRow) throw new Error("Can't add a fold to this FoldLine as it has no connection"); + this.folds.push(fold), this.folds.sort(function(a, b) { + return -a.range.compareEnd(b.start.row, b.start.column); + }), this.range.compareEnd(fold.start.row, fold.start.column) > 0 ? (this.end.row = fold.end.row, this.end.column = fold.end.column) : 0 > this.range.compareStart(fold.end.row, fold.end.column) && (this.start.row = fold.start.row, this.start.column = fold.start.column); + } else if (fold.start.row == this.end.row) this.folds.push(fold), this.end.row = fold.end.row, this.end.column = fold.end.column; + else if (fold.end.row == this.start.row) this.folds.unshift(fold), this.start.row = fold.start.row, this.start.column = fold.start.column; + else throw new Error("Trying to add fold to FoldRow that doesn't have a matching row"); + fold.foldLine = this; + }, this.containsRow = function(row) { + return row >= this.start.row && row <= this.end.row; + }, this.walk = function(callback, endRow, endColumn) { + var fold, cmp, lastEnd = 0, folds = this.folds, isNewRow = !0; + null == endRow && (endRow = this.end.row, endColumn = this.end.column); + for(var i = 0; i < folds.length; i++){ + if (-1 == (cmp = (fold = folds[i]).range.compareStart(endRow, endColumn))) { + callback(null, endRow, endColumn, lastEnd, isNewRow); + return; + } + if (!callback(null, fold.start.row, fold.start.column, lastEnd, isNewRow) && callback(fold.placeholder, fold.start.row, fold.start.column, lastEnd) || 0 === cmp) return; + isNewRow = !fold.sameRow, lastEnd = fold.end.column; + } + callback(null, endRow, endColumn, lastEnd, isNewRow); + }, this.getNextFoldTo = function(row, column) { + for(var fold, cmp, i = 0; i < this.folds.length; i++){ + if (-1 == (cmp = (fold = this.folds[i]).range.compareEnd(row, column))) return { + fold: fold, + kind: "after" + }; + if (0 === cmp) return { + fold: fold, + kind: "inside" + }; + } + return null; + }, this.addRemoveChars = function(row, column, len) { + var fold, folds, ret = this.getNextFoldTo(row, column); + if (ret) { + if (fold = ret.fold, "inside" == ret.kind && fold.start.column != column && fold.start.row != row) window.console && window.console.log(row, column, fold); + else if (fold.start.row == row) { + var i = (folds = this.folds).indexOf(fold); + for(0 === i && (this.start.column += len); i < folds.length; i++){ + if (fold = folds[i], fold.start.column += len, !fold.sameRow) return; + fold.end.column += len; + } + this.end.column += len; + } + } + }, this.split = function(row, column) { + var pos = this.getNextFoldTo(row, column); + if (!pos || "inside" == pos.kind) return null; + var fold = pos.fold, folds = this.folds, foldData = this.foldData, i = folds.indexOf(fold), foldBefore = folds[i - 1]; + this.end.row = foldBefore.end.row, this.end.column = foldBefore.end.column, folds = folds.splice(i, folds.length - i); + var newFoldLine = new FoldLine(foldData, folds); + return foldData.splice(foldData.indexOf(this) + 1, 0, newFoldLine), newFoldLine; + }, this.merge = function(foldLineNext) { + for(var folds = foldLineNext.folds, i = 0; i < folds.length; i++)this.addFold(folds[i]); + var foldData = this.foldData; + foldData.splice(foldData.indexOf(foldLineNext), 1); + }, this.toString = function() { + var ret = [ + this.range.toString() + ": [" + ]; + return this.folds.forEach(function(fold) { + ret.push(" " + fold.toString()); + }), ret.push("]"), ret.join("\n"); + }, this.idxToPosition = function(idx) { + for(var lastFoldEndColumn = 0, i = 0; i < this.folds.length; i++){ + var fold = this.folds[i]; + if ((idx -= fold.start.column - lastFoldEndColumn) < 0) return { + row: fold.start.row, + column: fold.start.column + idx + }; + if ((idx -= fold.placeholder.length) < 0) return fold.start; + lastFoldEndColumn = fold.end.column; + } + return { + row: this.end.row, + column: this.end.column + idx + }; + }; + }).call(FoldLine.prototype), exports.FoldLine = FoldLine; + }), ace.define("ace/range_list", [ + "require", + "exports", + "module", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var comparePoints = require("./range").Range.comparePoints, RangeList = function() { + this.ranges = [], this.$bias = 1; + }; + (function() { + this.comparePoints = comparePoints, this.pointIndex = function(pos, excludeEdges, startIndex) { + for(var list = this.ranges, i = startIndex || 0; i < list.length; i++){ + var range = list[i], cmpEnd = comparePoints(pos, range.end); + if (!(cmpEnd > 0)) { + var cmpStart = comparePoints(pos, range.start); + if (0 === cmpEnd) return excludeEdges && 0 !== cmpStart ? -i - 2 : i; + if (cmpStart > 0 || 0 === cmpStart && !excludeEdges) return i; + return -i - 1; + } + } + return -i - 1; + }, this.add = function(range) { + var excludeEdges = !range.isEmpty(), startIndex = this.pointIndex(range.start, excludeEdges); + startIndex < 0 && (startIndex = -startIndex - 1); + var endIndex = this.pointIndex(range.end, excludeEdges, startIndex); + return endIndex < 0 ? endIndex = -endIndex - 1 : endIndex++, this.ranges.splice(startIndex, endIndex - startIndex, range); + }, this.addList = function(list) { + for(var removed = [], i = list.length; i--;)removed.push.apply(removed, this.add(list[i])); + return removed; + }, this.substractPoint = function(pos) { + var i = this.pointIndex(pos); + if (i >= 0) return this.ranges.splice(i, 1); + }, this.merge = function() { + for(var range, removed = [], list = this.ranges, next = (list = list.sort(function(a, b) { + return comparePoints(a.start, b.start); + }))[0], i = 1; i < list.length; i++){ + range = next, next = list[i]; + var cmp = comparePoints(range.end, next.start); + !(cmp < 0) && (0 != cmp || range.isEmpty() || next.isEmpty()) && (0 > comparePoints(range.end, next.end) && (range.end.row = next.end.row, range.end.column = next.end.column), list.splice(i, 1), removed.push(next), next = range, i--); + } + return this.ranges = list, removed; + }, this.contains = function(row, column) { + return this.pointIndex({ + row: row, + column: column + }) >= 0; + }, this.containsPoint = function(pos) { + return this.pointIndex(pos) >= 0; + }, this.rangeAtPoint = function(pos) { + var i = this.pointIndex(pos); + if (i >= 0) return this.ranges[i]; + }, this.clipRows = function(startRow, endRow) { + var list = this.ranges; + if (list[0].start.row > endRow || list[list.length - 1].start.row < startRow) return []; + var startIndex = this.pointIndex({ + row: startRow, + column: 0 + }); + startIndex < 0 && (startIndex = -startIndex - 1); + var endIndex = this.pointIndex({ + row: endRow, + column: 0 + }, startIndex); + endIndex < 0 && (endIndex = -endIndex - 1); + for(var clipped = [], i = startIndex; i < endIndex; i++)clipped.push(list[i]); + return clipped; + }, this.removeAll = function() { + return this.ranges.splice(0, this.ranges.length); + }, this.attach = function(session) { + this.session && this.detach(), this.session = session, this.onChange = this.$onChange.bind(this), this.session.on('change', this.onChange); + }, this.detach = function() { + this.session && (this.session.removeListener('change', this.onChange), this.session = null); + }, this.$onChange = function(delta) { + for(var start = delta.start, end = delta.end, startRow = start.row, endRow = end.row, ranges = this.ranges, i = 0, n = ranges.length; i < n; i++){ + var r = ranges[i]; + if (r.end.row >= startRow) break; + } + if ("insert" == delta.action) for(var lineDif = endRow - startRow, colDiff = -start.column + end.column; i < n; i++){ + var r = ranges[i]; + if (r.start.row > startRow) break; + if (r.start.row == startRow && r.start.column >= start.column && (r.start.column == start.column && this.$bias <= 0 || (r.start.column += colDiff, r.start.row += lineDif)), r.end.row == startRow && r.end.column >= start.column) { + if (r.end.column == start.column && this.$bias < 0) continue; + r.end.column == start.column && colDiff > 0 && i < n - 1 && r.end.column > r.start.column && r.end.column == ranges[i + 1].start.column && (r.end.column -= colDiff), r.end.column += colDiff, r.end.row += lineDif; + } + } + else for(var lineDif = startRow - endRow, colDiff = start.column - end.column; i < n; i++){ + var r = ranges[i]; + if (r.start.row > endRow) break; + r.end.row < endRow && (startRow < r.end.row || startRow == r.end.row && start.column < r.end.column) ? (r.end.row = startRow, r.end.column = start.column) : r.end.row == endRow ? r.end.column <= end.column ? (lineDif || r.end.column > start.column) && (r.end.column = start.column, r.end.row = start.row) : (r.end.column += colDiff, r.end.row += lineDif) : r.end.row > endRow && (r.end.row += lineDif), r.start.row < endRow && (startRow < r.start.row || startRow == r.start.row && start.column < r.start.column) ? (r.start.row = startRow, r.start.column = start.column) : r.start.row == endRow ? r.start.column <= end.column ? (lineDif || r.start.column > start.column) && (r.start.column = start.column, r.start.row = start.row) : (r.start.column += colDiff, r.start.row += lineDif) : r.start.row > endRow && (r.start.row += lineDif); + } + if (0 != lineDif && i < n) for(; i < n; i++){ + var r = ranges[i]; + r.start.row += lineDif, r.end.row += lineDif; + } + }; + }).call(RangeList.prototype), exports.RangeList = RangeList; + }), ace.define("ace/edit_session/fold", [ + "require", + "exports", + "module", + "ace/range_list", + "ace/lib/oop" + ], function(require, exports, module) { + "use strict"; + var RangeList = require("../range_list").RangeList, oop = require("../lib/oop"), Fold = exports.Fold = function(range, placeholder) { + this.foldLine = null, this.placeholder = placeholder, this.range = range, this.start = range.start, this.end = range.end, this.sameRow = range.start.row == range.end.row, this.subFolds = this.ranges = []; + }; + function consumePoint(point, anchor) { + point.row -= anchor.row, 0 == point.row && (point.column -= anchor.column); + } + function restorePoint(point, anchor) { + 0 == point.row && (point.column += anchor.column), point.row += anchor.row; + } + oop.inherits(Fold, RangeList), (function() { + this.toString = function() { + return '"' + this.placeholder + '" ' + this.range.toString(); + }, this.setFoldLine = function(foldLine) { + this.foldLine = foldLine, this.subFolds.forEach(function(fold) { + fold.setFoldLine(foldLine); + }); + }, this.clone = function() { + var range = this.range.clone(), fold = new Fold(range, this.placeholder); + return this.subFolds.forEach(function(subFold) { + fold.subFolds.push(subFold.clone()); + }), fold.collapseChildren = this.collapseChildren, fold; + }, this.addSubFold = function(fold) { + if (!this.range.isEqual(fold)) { + range = fold, anchor = this.start, consumePoint(range.start, anchor), consumePoint(range.end, anchor); + for(var range, anchor, row = fold.start.row, column = fold.start.column, i = 0, cmp = -1; i < this.subFolds.length && 1 == (cmp = this.subFolds[i].range.compare(row, column)); i++); + var afterStart = this.subFolds[i], firstConsumed = 0; + if (0 == cmp) { + if (afterStart.range.containsRange(fold)) return afterStart.addSubFold(fold); + firstConsumed = 1; + } + for(var row = fold.range.end.row, column = fold.range.end.column, j = i, cmp = -1; j < this.subFolds.length && 1 == (cmp = this.subFolds[j].range.compare(row, column)); j++); + 0 == cmp && j++; + for(var consumedFolds = this.subFolds.splice(i, j - i, fold), last = 0 == cmp ? consumedFolds.length - 1 : consumedFolds.length, k = firstConsumed; k < last; k++)fold.addSubFold(consumedFolds[k]); + return fold.setFoldLine(this.foldLine), fold; + } + }, this.restoreRange = function(range) { + var range1, anchor; + return range1 = range, anchor = this.start, void (restorePoint(range1.start, anchor), restorePoint(range1.end, anchor)); + }; + }).call(Fold.prototype); + }), ace.define("ace/edit_session/folding", [ + "require", + "exports", + "module", + "ace/range", + "ace/edit_session/fold_line", + "ace/edit_session/fold", + "ace/token_iterator" + ], function(require, exports, module) { + "use strict"; + var Range = require("../range").Range, FoldLine = require("./fold_line").FoldLine, Fold = require("./fold").Fold, TokenIterator = require("../token_iterator").TokenIterator; + exports.Folding = function() { + this.getFoldAt = function(row, column, side) { + var foldLine = this.getFoldLine(row); + if (!foldLine) return null; + for(var folds = foldLine.folds, i = 0; i < folds.length; i++){ + var range = folds[i].range; + if (range.contains(row, column)) { + if (1 == side && range.isEnd(row, column) && !range.isEmpty()) continue; + if (-1 == side && range.isStart(row, column) && !range.isEmpty()) continue; + return folds[i]; + } + } + }, this.getFoldsInRange = function(range) { + var start = range.start, end = range.end, foldLines = this.$foldData, foundFolds = []; + start.column += 1, end.column -= 1; + for(var i = 0; i < foldLines.length; i++){ + var cmp = foldLines[i].range.compareRange(range); + if (2 != cmp) { + if (-2 == cmp) break; + for(var folds = foldLines[i].folds, j = 0; j < folds.length; j++){ + var fold = folds[j]; + if (-2 == (cmp = fold.range.compareRange(range))) break; + if (2 != cmp) { + if (42 == cmp) break; + foundFolds.push(fold); + } + } + } + } + return start.column -= 1, end.column += 1, foundFolds; + }, this.getFoldsInRangeList = function(ranges) { + if (Array.isArray(ranges)) { + var folds = []; + ranges.forEach(function(range) { + folds = folds.concat(this.getFoldsInRange(range)); + }, this); + } else var folds = this.getFoldsInRange(ranges); + return folds; + }, this.getAllFolds = function() { + for(var folds = [], foldLines = this.$foldData, i = 0; i < foldLines.length; i++)for(var j = 0; j < foldLines[i].folds.length; j++)folds.push(foldLines[i].folds[j]); + return folds; + }, this.getFoldStringAt = function(row, column, trim, foldLine) { + if (!(foldLine = foldLine || this.getFoldLine(row))) return null; + for(var str, fold, lastFold = { + end: { + column: 0 + } + }, i = 0; i < foldLine.folds.length; i++){ + var cmp = (fold = foldLine.folds[i]).range.compareEnd(row, column); + if (-1 == cmp) { + str = this.getLine(fold.start.row).substring(lastFold.end.column, fold.start.column); + break; + } + if (0 === cmp) return null; + lastFold = fold; + } + return (str || (str = this.getLine(fold.start.row).substring(lastFold.end.column)), -1 == trim) ? str.substring(0, column - lastFold.end.column) : 1 == trim ? str.substring(column - lastFold.end.column) : str; + }, this.getFoldLine = function(docRow, startFoldLine) { + var foldData = this.$foldData, i = 0; + for(startFoldLine && (i = foldData.indexOf(startFoldLine)), -1 == i && (i = 0); i < foldData.length; i++){ + var foldLine = foldData[i]; + if (foldLine.start.row <= docRow && foldLine.end.row >= docRow) return foldLine; + if (foldLine.end.row > docRow) return null; + } + return null; + }, this.getNextFoldLine = function(docRow, startFoldLine) { + var foldData = this.$foldData, i = 0; + for(startFoldLine && (i = foldData.indexOf(startFoldLine)), -1 == i && (i = 0); i < foldData.length; i++){ + var foldLine = foldData[i]; + if (foldLine.end.row >= docRow) return foldLine; + } + return null; + }, this.getFoldedRowCount = function(first, last) { + for(var foldData = this.$foldData, rowCount = last - first + 1, i = 0; i < foldData.length; i++){ + var foldLine = foldData[i], end = foldLine.end.row, start = foldLine.start.row; + if (end >= last) { + start < last && (start >= first ? rowCount -= last - start : rowCount = 0); + break; + } + end >= first && (start >= first ? rowCount -= end - start : rowCount -= end - first + 1); + } + return rowCount; + }, this.$addFoldLine = function(foldLine) { + return this.$foldData.push(foldLine), this.$foldData.sort(function(a, b) { + return a.start.row - b.start.row; + }), foldLine; + }, this.addFold = function(placeholder, range) { + var fold, foldData = this.$foldData, added = !1; + placeholder instanceof Fold ? fold = placeholder : (fold = new Fold(range, placeholder)).collapseChildren = range.collapseChildren, this.$clipRangeToDocument(fold.range); + var startRow = fold.start.row, startColumn = fold.start.column, endRow = fold.end.row, endColumn = fold.end.column, startFold = this.getFoldAt(startRow, startColumn, 1), endFold = this.getFoldAt(endRow, endColumn, -1); + if (startFold && endFold == startFold) return startFold.addSubFold(fold); + startFold && !startFold.range.isStart(startRow, startColumn) && this.removeFold(startFold), endFold && !endFold.range.isEnd(endRow, endColumn) && this.removeFold(endFold); + var folds = this.getFoldsInRange(fold.range); + folds.length > 0 && (this.removeFolds(folds), fold.collapseChildren || folds.forEach(function(subFold) { + fold.addSubFold(subFold); + })); + for(var i = 0; i < foldData.length; i++){ + var foldLine = foldData[i]; + if (endRow == foldLine.start.row) { + foldLine.addFold(fold), added = !0; + break; + } + if (startRow == foldLine.end.row) { + if (foldLine.addFold(fold), added = !0, !fold.sameRow) { + var foldLineNext = foldData[i + 1]; + if (foldLineNext && foldLineNext.start.row == endRow) { + foldLine.merge(foldLineNext); + break; + } + } + break; + } + if (endRow <= foldLine.start.row) break; + } + return added || (foldLine = this.$addFoldLine(new FoldLine(this.$foldData, fold))), this.$useWrapMode ? this.$updateWrapData(foldLine.start.row, foldLine.start.row) : this.$updateRowLengthCache(foldLine.start.row, foldLine.start.row), this.$modified = !0, this._signal("changeFold", { + data: fold, + action: "add" + }), fold; + }, this.addFolds = function(folds) { + folds.forEach(function(fold) { + this.addFold(fold); + }, this); + }, this.removeFold = function(fold) { + var foldLine = fold.foldLine, startRow = foldLine.start.row, endRow = foldLine.end.row, foldLines = this.$foldData, folds = foldLine.folds; + if (1 == folds.length) foldLines.splice(foldLines.indexOf(foldLine), 1); + else if (foldLine.range.isEnd(fold.end.row, fold.end.column)) folds.pop(), foldLine.end.row = folds[folds.length - 1].end.row, foldLine.end.column = folds[folds.length - 1].end.column; + else if (foldLine.range.isStart(fold.start.row, fold.start.column)) folds.shift(), foldLine.start.row = folds[0].start.row, foldLine.start.column = folds[0].start.column; + else if (fold.sameRow) folds.splice(folds.indexOf(fold), 1); + else { + var newFoldLine = foldLine.split(fold.start.row, fold.start.column); + (folds = newFoldLine.folds).shift(), newFoldLine.start.row = folds[0].start.row, newFoldLine.start.column = folds[0].start.column; + } + this.$updating || (this.$useWrapMode ? this.$updateWrapData(startRow, endRow) : this.$updateRowLengthCache(startRow, endRow)), this.$modified = !0, this._signal("changeFold", { + data: fold, + action: "remove" + }); + }, this.removeFolds = function(folds) { + for(var cloneFolds = [], i = 0; i < folds.length; i++)cloneFolds.push(folds[i]); + cloneFolds.forEach(function(fold) { + this.removeFold(fold); + }, this), this.$modified = !0; + }, this.expandFold = function(fold) { + this.removeFold(fold), fold.subFolds.forEach(function(subFold) { + fold.restoreRange(subFold), this.addFold(subFold); + }, this), fold.collapseChildren > 0 && this.foldAll(fold.start.row + 1, fold.end.row, fold.collapseChildren - 1), fold.subFolds = []; + }, this.expandFolds = function(folds) { + folds.forEach(function(fold) { + this.expandFold(fold); + }, this); + }, this.unfold = function(location, expandInner) { + if (null == location) range2 = new Range(0, 0, this.getLength(), 0), null == expandInner && (expandInner = !0); + else if ("number" == typeof location) range2 = new Range(location, 0, location, this.getLine(location).length); + else if ("row" in location) range2 = Range.fromPoints(location, location); + else { + if (Array.isArray(location)) return folds = [], location.forEach(function(range) { + folds = folds.concat(this.unfold(range)); + }, this), folds; + range2 = location; + } + for(var range2, folds, outermostFolds = folds = this.getFoldsInRangeList(range2); 1 == folds.length && 0 > Range.comparePoints(folds[0].start, range2.start) && Range.comparePoints(folds[0].end, range2.end) > 0;)this.expandFolds(folds), folds = this.getFoldsInRangeList(range2); + if (!1 != expandInner ? this.removeFolds(folds) : this.expandFolds(folds), outermostFolds.length) return outermostFolds; + }, this.isRowFolded = function(docRow, startFoldRow) { + return !!this.getFoldLine(docRow, startFoldRow); + }, this.getRowFoldEnd = function(docRow, startFoldRow) { + var foldLine = this.getFoldLine(docRow, startFoldRow); + return foldLine ? foldLine.end.row : docRow; + }, this.getRowFoldStart = function(docRow, startFoldRow) { + var foldLine = this.getFoldLine(docRow, startFoldRow); + return foldLine ? foldLine.start.row : docRow; + }, this.getFoldDisplayLine = function(foldLine, endRow, endColumn, startRow, startColumn) { + null == startRow && (startRow = foldLine.start.row), null == startColumn && (startColumn = 0), null == endRow && (endRow = foldLine.end.row), null == endColumn && (endColumn = this.getLine(endRow).length); + var doc = this.doc, textLine = ""; + return foldLine.walk(function(placeholder, row, column, lastColumn) { + if (!(row < startRow)) { + if (row == startRow) { + if (column < startColumn) return; + lastColumn = Math.max(startColumn, lastColumn); + } + null != placeholder ? textLine += placeholder : textLine += doc.getLine(row).substring(lastColumn, column); + } + }, endRow, endColumn), textLine; + }, this.getDisplayLine = function(row, endColumn, startRow, startColumn) { + var line, foldLine = this.getFoldLine(row); + return foldLine ? this.getFoldDisplayLine(foldLine, row, endColumn, startRow, startColumn) : (line = this.doc.getLine(row)).substring(startColumn || 0, endColumn || line.length); + }, this.$cloneFoldData = function() { + var fd = []; + return fd = this.$foldData.map(function(foldLine) { + var folds = foldLine.folds.map(function(fold) { + return fold.clone(); + }); + return new FoldLine(fd, folds); + }); + }, this.toggleFold = function(tryToUnfold) { + var fold, bracketPos, range = this.selection.getRange(); + if (range.isEmpty()) { + var cursor = range.start; + if (fold = this.getFoldAt(cursor.row, cursor.column)) { + this.expandFold(fold); + return; + } + (bracketPos = this.findMatchingBracket(cursor)) ? 1 == range.comparePoint(bracketPos) ? range.end = bracketPos : (range.start = bracketPos, range.start.column++, range.end.column--) : (bracketPos = this.findMatchingBracket({ + row: cursor.row, + column: cursor.column + 1 + })) ? (1 == range.comparePoint(bracketPos) ? range.end = bracketPos : range.start = bracketPos, range.start.column++) : range = this.getCommentFoldRange(cursor.row, cursor.column) || range; + } else { + var folds = this.getFoldsInRange(range); + if (tryToUnfold && folds.length) { + this.expandFolds(folds); + return; + } + 1 == folds.length && (fold = folds[0]); + } + if (fold || (fold = this.getFoldAt(range.start.row, range.start.column)), fold && fold.range.toString() == range.toString()) { + this.expandFold(fold); + return; + } + var placeholder = "..."; + if (!range.isMultiLine()) { + if ((placeholder = this.getTextRange(range)).length < 4) return; + placeholder = placeholder.trim().substring(0, 2) + ".."; + } + this.addFold(placeholder, range); + }, this.getCommentFoldRange = function(row, column, dir) { + var iterator = new TokenIterator(this, row, column), token = iterator.getCurrentToken(), type = token && token.type; + if (token && /^comment|string/.test(type)) { + "comment" == (type = type.match(/comment|string/)[0]) && (type += "|doc-start"); + var re = new RegExp(type), range = new Range(); + if (1 != dir) { + do token = iterator.stepBackward(); + while (token && re.test(token.type)) + iterator.stepForward(); + } + if (range.start.row = iterator.getCurrentTokenRow(), range.start.column = iterator.getCurrentTokenColumn() + 2, iterator = new TokenIterator(this, row, column), -1 != dir) { + var lastRow = -1; + do if (token = iterator.stepForward(), -1 == lastRow) { + var state = this.getState(iterator.$row); + re.test(state) || (lastRow = iterator.$row); + } else if (iterator.$row > lastRow) break; + while (token && re.test(token.type)) + token = iterator.stepBackward(); + } else token = iterator.getCurrentToken(); + return range.end.row = iterator.getCurrentTokenRow(), range.end.column = iterator.getCurrentTokenColumn() + token.value.length - 2, range; + } + }, this.foldAll = function(startRow, endRow, depth, test) { + void 0 == depth && (depth = 100000); + var foldWidgets = this.foldWidgets; + if (foldWidgets) { + endRow = endRow || this.getLength(), startRow = startRow || 0; + for(var row = startRow; row < endRow; row++)if (null == foldWidgets[row] && (foldWidgets[row] = this.getFoldWidget(row)), "start" == foldWidgets[row] && (!test || test(row))) { + var range = this.getFoldWidgetRange(row); + range && range.isMultiLine() && range.end.row <= endRow && range.start.row >= startRow && (row = range.end.row, range.collapseChildren = depth, this.addFold("...", range)); + } + } + }, this.foldToLevel = function(level) { + for(this.foldAll(); level-- > 0;)this.unfold(null, !1); + }, this.foldAllComments = function() { + var session = this; + this.foldAll(null, null, null, function(row) { + for(var tokens = session.getTokens(row), i = 0; i < tokens.length; i++){ + var token = tokens[i]; + if (!("text" == token.type && /^\s+$/.test(token.value))) { + if (/comment/.test(token.type)) return !0; + return !1; + } + } + }); + }, this.$foldStyles = { + manual: 1, + markbegin: 1, + markbeginend: 1 + }, this.$foldStyle = "markbegin", this.setFoldStyle = function(style) { + if (!this.$foldStyles[style]) throw new Error("invalid fold style: " + style + "[" + Object.keys(this.$foldStyles).join(", ") + "]"); + if (this.$foldStyle != style) { + this.$foldStyle = style, "manual" == style && this.unfold(); + var mode = this.$foldMode; + this.$setFolding(null), this.$setFolding(mode); + } + }, this.$setFolding = function(foldMode) { + if (this.$foldMode != foldMode) { + if (this.$foldMode = foldMode, this.off('change', this.$updateFoldWidgets), this.off('tokenizerUpdate', this.$tokenizerUpdateFoldWidgets), this._signal("changeAnnotation"), !foldMode || "manual" == this.$foldStyle) { + this.foldWidgets = null; + return; + } + this.foldWidgets = [], this.getFoldWidget = foldMode.getFoldWidget.bind(foldMode, this, this.$foldStyle), this.getFoldWidgetRange = foldMode.getFoldWidgetRange.bind(foldMode, this, this.$foldStyle), this.$updateFoldWidgets = this.updateFoldWidgets.bind(this), this.$tokenizerUpdateFoldWidgets = this.tokenizerUpdateFoldWidgets.bind(this), this.on('change', this.$updateFoldWidgets), this.on('tokenizerUpdate', this.$tokenizerUpdateFoldWidgets); + } + }, this.getParentFoldRangeData = function(row, ignoreCurrent) { + var fw = this.foldWidgets; + if (!fw || ignoreCurrent && fw[row]) return {}; + for(var firstRange, i = row - 1; i >= 0;){ + var c = fw[i]; + if (null == c && (c = fw[i] = this.getFoldWidget(i)), "start" == c) { + var range = this.getFoldWidgetRange(i); + if (firstRange || (firstRange = range), range && range.end.row >= row) break; + } + i--; + } + return { + range: -1 !== i && range, + firstRange: firstRange + }; + }, this.onFoldWidgetClick = function(row, e) { + var options = { + children: (e = e.domEvent).shiftKey, + all: e.ctrlKey || e.metaKey, + siblings: e.altKey + }; + if (!this.$toggleFoldWidget(row, options)) { + var el = e.target || e.srcElement; + el && /ace_fold-widget/.test(el.className) && (el.className += " ace_invalid"); + } + }, this.$toggleFoldWidget = function(row, options) { + if (this.getFoldWidget) { + var type = this.getFoldWidget(row), line = this.getLine(row), dir = "end" === type ? -1 : 1, fold = this.getFoldAt(row, -1 === dir ? 0 : line.length, dir); + if (fold) return options.children || options.all ? this.removeFold(fold) : this.expandFold(fold), fold; + var range = this.getFoldWidgetRange(row, !0); + if (range && !range.isMultiLine() && (fold = this.getFoldAt(range.start.row, range.start.column, 1)) && range.isEqual(fold.range)) return this.removeFold(fold), fold; + if (options.siblings) { + var data = this.getParentFoldRangeData(row); + if (data.range) var startRow = data.range.start.row + 1, endRow = data.range.end.row; + this.foldAll(startRow, endRow, options.all ? 10000 : 0); + } else options.children ? (endRow = range ? range.end.row : this.getLength(), this.foldAll(row + 1, endRow, options.all ? 10000 : 0)) : range && (options.all && (range.collapseChildren = 10000), this.addFold("...", range)); + return range; + } + }, this.toggleFoldWidget = function(toggleParent) { + var row = this.selection.getCursor().row; + row = this.getRowFoldStart(row); + var range = this.$toggleFoldWidget(row, {}); + if (!range) { + var data = this.getParentFoldRangeData(row, !0); + if (range = data.range || data.firstRange) { + row = range.start.row; + var fold = this.getFoldAt(row, this.getLine(row).length, 1); + fold ? this.removeFold(fold) : this.addFold("...", range); + } + } + }, this.updateFoldWidgets = function(delta) { + var firstRow = delta.start.row, len = delta.end.row - firstRow; + if (0 === len) this.foldWidgets[firstRow] = null; + else if ('remove' == delta.action) this.foldWidgets.splice(firstRow, len + 1, null); + else { + var args = Array(len + 1); + args.unshift(firstRow, 1), this.foldWidgets.splice.apply(this.foldWidgets, args); + } + }, this.tokenizerUpdateFoldWidgets = function(e) { + var rows = e.data; + rows.first != rows.last && this.foldWidgets.length > rows.first && this.foldWidgets.splice(rows.first, this.foldWidgets.length); + }; + }; + }), ace.define("ace/edit_session/bracket_match", [ + "require", + "exports", + "module", + "ace/token_iterator", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var TokenIterator = require("../token_iterator").TokenIterator, Range = require("../range").Range; + exports.BracketMatch = function() { + this.findMatchingBracket = function(position, chr) { + if (0 == position.column) return null; + var charBeforeCursor = chr || this.getLine(position.row).charAt(position.column - 1); + if ("" == charBeforeCursor) return null; + var match = charBeforeCursor.match(/([\(\[\{])|([\)\]\}])/); + return match ? match[1] ? this.$findClosingBracket(match[1], position) : this.$findOpeningBracket(match[2], position) : null; + }, this.getBracketRange = function(pos) { + var range, line = this.getLine(pos.row), before = !0, chr = line.charAt(pos.column - 1), match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + if (match || (chr = line.charAt(pos.column), pos = { + row: pos.row, + column: pos.column + 1 + }, match = chr && chr.match(/([\(\[\{])|([\)\]\}])/), before = !1), !match) return null; + if (match[1]) { + var bracketPos = this.$findClosingBracket(match[1], pos); + if (!bracketPos) return null; + range = Range.fromPoints(pos, bracketPos), !before && (range.end.column++, range.start.column--), range.cursor = range.end; + } else { + var bracketPos = this.$findOpeningBracket(match[2], pos); + if (!bracketPos) return null; + range = Range.fromPoints(bracketPos, pos), !before && (range.start.column++, range.end.column--), range.cursor = range.start; + } + return range; + }, this.getMatchingBracketRanges = function(pos) { + var line = this.getLine(pos.row), chr = line.charAt(pos.column - 1), match = chr && chr.match(/([\(\[\{])|([\)\]\}])/); + if (match || (chr = line.charAt(pos.column), pos = { + row: pos.row, + column: pos.column + 1 + }, match = chr && chr.match(/([\(\[\{])|([\)\]\}])/)), !match) return null; + var startRange = new Range(pos.row, pos.column - 1, pos.row, pos.column), bracketPos = match[1] ? this.$findClosingBracket(match[1], pos) : this.$findOpeningBracket(match[2], pos); + return bracketPos ? [ + startRange, + new Range(bracketPos.row, bracketPos.column, bracketPos.row, bracketPos.column + 1) + ] : [ + startRange + ]; + }, this.$brackets = { + ")": "(", + "(": ")", + "]": "[", + "[": "]", + "{": "}", + "}": "{", + "<": ">", + ">": "<" + }, this.$findOpeningBracket = function(bracket, position, typeRe) { + var openBracket = this.$brackets[bracket], depth = 1, iterator = new TokenIterator(this, position.row, position.column), token = iterator.getCurrentToken(); + if (token || (token = iterator.stepForward()), token) { + typeRe || (typeRe = new RegExp("(\\.?" + token.type.replace(".", "\\.").replace("rparen", ".paren").replace(/\b(?:end)\b/, "(?:start|begin|end)") + ")+")); + for(var valueIndex = position.column - iterator.getCurrentTokenColumn() - 2, value = token.value;;){ + for(; valueIndex >= 0;){ + var chr = value.charAt(valueIndex); + if (chr == openBracket) { + if (0 == (depth -= 1)) return { + row: iterator.getCurrentTokenRow(), + column: valueIndex + iterator.getCurrentTokenColumn() + }; + } else chr == bracket && (depth += 1); + valueIndex -= 1; + } + do token = iterator.stepBackward(); + while (token && !typeRe.test(token.type)) + if (null == token) break; + valueIndex = (value = token.value).length - 1; + } + return null; + } + }, this.$findClosingBracket = function(bracket, position, typeRe) { + var closingBracket = this.$brackets[bracket], depth = 1, iterator = new TokenIterator(this, position.row, position.column), token = iterator.getCurrentToken(); + if (token || (token = iterator.stepForward()), token) { + typeRe || (typeRe = new RegExp("(\\.?" + token.type.replace(".", "\\.").replace("lparen", ".paren").replace(/\b(?:start|begin)\b/, "(?:start|begin|end)") + ")+")); + for(var valueIndex = position.column - iterator.getCurrentTokenColumn();;){ + for(var value = token.value, valueLength = value.length; valueIndex < valueLength;){ + var chr = value.charAt(valueIndex); + if (chr == closingBracket) { + if (0 == (depth -= 1)) return { + row: iterator.getCurrentTokenRow(), + column: valueIndex + iterator.getCurrentTokenColumn() + }; + } else chr == bracket && (depth += 1); + valueIndex += 1; + } + do token = iterator.stepForward(); + while (token && !typeRe.test(token.type)) + if (null == token) break; + valueIndex = 0; + } + return null; + } + }; + }; + }), ace.define("ace/edit_session", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/lang", + "ace/bidihandler", + "ace/config", + "ace/lib/event_emitter", + "ace/selection", + "ace/mode/text", + "ace/range", + "ace/document", + "ace/background_tokenizer", + "ace/search_highlight", + "ace/edit_session/folding", + "ace/edit_session/bracket_match" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), lang = require("./lib/lang"), BidiHandler = require("./bidihandler").BidiHandler, config = require("./config"), EventEmitter = require("./lib/event_emitter").EventEmitter, Selection = require("./selection").Selection, TextMode = require("./mode/text").Mode, Range = require("./range").Range, Document = require("./document").Document, BackgroundTokenizer = require("./background_tokenizer").BackgroundTokenizer, SearchHighlight = require("./search_highlight").SearchHighlight, EditSession = function(text, mode) { + this.$breakpoints = [], this.$decorations = [], this.$frontMarkers = {}, this.$backMarkers = {}, this.$markerId = 1, this.$undoSelect = !0, this.$foldData = [], this.id = "session" + ++EditSession.$uid, this.$foldData.toString = function() { + return this.join("\n"); + }, this.on("changeFold", this.onChangeFold.bind(this)), this.$onChange = this.onChange.bind(this), "object" == typeof text && text.getLine || (text = new Document(text)), this.setDocument(text), this.selection = new Selection(this), this.$bidiHandler = new BidiHandler(this), config.resetOptions(this), this.setMode(mode), config._signal("session", this); + }; + EditSession.$uid = 0, (function() { + oop.implement(this, EventEmitter), this.setDocument = function(doc) { + this.doc && this.doc.off("change", this.$onChange), this.doc = doc, doc.on("change", this.$onChange), this.bgTokenizer && this.bgTokenizer.setDocument(this.getDocument()), this.resetCaches(); + }, this.getDocument = function() { + return this.doc; + }, this.$resetRowCache = function(docRow) { + if (!docRow) { + this.$docRowCache = [], this.$screenRowCache = []; + return; + } + var l = this.$docRowCache.length, i = this.$getRowCacheIndex(this.$docRowCache, docRow) + 1; + l > i && (this.$docRowCache.splice(i, l), this.$screenRowCache.splice(i, l)); + }, this.$getRowCacheIndex = function(cacheArray, val) { + for(var low = 0, hi = cacheArray.length - 1; low <= hi;){ + var mid = low + hi >> 1, c = cacheArray[mid]; + if (val > c) low = mid + 1; + else { + if (!(val < c)) return mid; + hi = mid - 1; + } + } + return low - 1; + }, this.resetCaches = function() { + this.$modified = !0, this.$wrapData = [], this.$rowLengthCache = [], this.$resetRowCache(0), this.bgTokenizer && this.bgTokenizer.start(0); + }, this.onChangeFold = function(e) { + var fold = e.data; + this.$resetRowCache(fold.start.row); + }, this.onChange = function(delta) { + this.$modified = !0, this.$bidiHandler.onChange(delta), this.$resetRowCache(delta.start.row); + var removedFolds = this.$updateInternalDataOnChange(delta); + !this.$fromUndo && this.$undoManager && (removedFolds && removedFolds.length && (this.$undoManager.add({ + action: "removeFolds", + folds: removedFolds + }, this.mergeUndoDeltas), this.mergeUndoDeltas = !0), this.$undoManager.add(delta, this.mergeUndoDeltas), this.mergeUndoDeltas = !0, this.$informUndoManager.schedule()), this.bgTokenizer && this.bgTokenizer.$updateOnChange(delta), this._signal("change", delta); + }, this.setValue = function(text) { + this.doc.setValue(text), this.selection.moveTo(0, 0), this.$resetRowCache(0), this.setUndoManager(this.$undoManager), this.getUndoManager().reset(); + }, this.getValue = this.toString = function() { + return this.doc.getValue(); + }, this.getSelection = function() { + return this.selection; + }, this.getState = function(row) { + return this.bgTokenizer.getState(row); + }, this.getTokens = function(row) { + return this.bgTokenizer.getTokens(row); + }, this.getTokenAt = function(row, column) { + var token, tokens = this.bgTokenizer.getTokens(row), c = 0; + if (null == column) { + var i = tokens.length - 1; + c = this.getLine(row).length; + } else for(var i = 0; i < tokens.length && !((c += tokens[i].value.length) >= column); i++); + return (token = tokens[i]) ? (token.index = i, token.start = c - token.value.length, token) : null; + }, this.setUndoManager = function(undoManager) { + if (this.$undoManager = undoManager, this.$informUndoManager && this.$informUndoManager.cancel(), undoManager) { + var self = this; + undoManager.addSession(this), this.$syncInformUndoManager = function() { + self.$informUndoManager.cancel(), self.mergeUndoDeltas = !1; + }, this.$informUndoManager = lang.delayedCall(this.$syncInformUndoManager); + } else this.$syncInformUndoManager = function() {}; + }, this.markUndoGroup = function() { + this.$syncInformUndoManager && this.$syncInformUndoManager(); + }, this.$defaultUndoManager = { + undo: function() {}, + redo: function() {}, + hasUndo: function() {}, + hasRedo: function() {}, + reset: function() {}, + add: function() {}, + addSelection: function() {}, + startNewGroup: function() {}, + addSession: function() {} + }, this.getUndoManager = function() { + return this.$undoManager || this.$defaultUndoManager; + }, this.getTabString = function() { + return this.getUseSoftTabs() ? lang.stringRepeat(" ", this.getTabSize()) : "\t"; + }, this.setUseSoftTabs = function(val) { + this.setOption("useSoftTabs", val); + }, this.getUseSoftTabs = function() { + return this.$useSoftTabs && !this.$mode.$indentWithTabs; + }, this.setTabSize = function(tabSize) { + this.setOption("tabSize", tabSize); + }, this.getTabSize = function() { + return this.$tabSize; + }, this.isTabStop = function(position) { + return this.$useSoftTabs && position.column % this.$tabSize == 0; + }, this.setNavigateWithinSoftTabs = function(navigateWithinSoftTabs) { + this.setOption("navigateWithinSoftTabs", navigateWithinSoftTabs); + }, this.getNavigateWithinSoftTabs = function() { + return this.$navigateWithinSoftTabs; + }, this.$overwrite = !1, this.setOverwrite = function(overwrite) { + this.setOption("overwrite", overwrite); + }, this.getOverwrite = function() { + return this.$overwrite; + }, this.toggleOverwrite = function() { + this.setOverwrite(!this.$overwrite); + }, this.addGutterDecoration = function(row, className) { + this.$decorations[row] || (this.$decorations[row] = ""), this.$decorations[row] += " " + className, this._signal("changeBreakpoint", {}); + }, this.removeGutterDecoration = function(row, className) { + this.$decorations[row] = (this.$decorations[row] || "").replace(" " + className, ""), this._signal("changeBreakpoint", {}); + }, this.getBreakpoints = function() { + return this.$breakpoints; + }, this.setBreakpoints = function(rows) { + this.$breakpoints = []; + for(var i = 0; i < rows.length; i++)this.$breakpoints[rows[i]] = "ace_breakpoint"; + this._signal("changeBreakpoint", {}); + }, this.clearBreakpoints = function() { + this.$breakpoints = [], this._signal("changeBreakpoint", {}); + }, this.setBreakpoint = function(row, className) { + void 0 === className && (className = "ace_breakpoint"), className ? this.$breakpoints[row] = className : delete this.$breakpoints[row], this._signal("changeBreakpoint", {}); + }, this.clearBreakpoint = function(row) { + delete this.$breakpoints[row], this._signal("changeBreakpoint", {}); + }, this.addMarker = function(range, clazz, type, inFront) { + var id = this.$markerId++, marker = { + range: range, + type: type || "line", + renderer: "function" == typeof type ? type : null, + clazz: clazz, + inFront: !!inFront, + id: id + }; + return inFront ? (this.$frontMarkers[id] = marker, this._signal("changeFrontMarker")) : (this.$backMarkers[id] = marker, this._signal("changeBackMarker")), id; + }, this.addDynamicMarker = function(marker, inFront) { + if (marker.update) { + var id = this.$markerId++; + return marker.id = id, marker.inFront = !!inFront, inFront ? (this.$frontMarkers[id] = marker, this._signal("changeFrontMarker")) : (this.$backMarkers[id] = marker, this._signal("changeBackMarker")), marker; + } + }, this.removeMarker = function(markerId) { + var marker = this.$frontMarkers[markerId] || this.$backMarkers[markerId]; + marker && (delete (marker.inFront ? this.$frontMarkers : this.$backMarkers)[markerId], this._signal(marker.inFront ? "changeFrontMarker" : "changeBackMarker")); + }, this.getMarkers = function(inFront) { + return inFront ? this.$frontMarkers : this.$backMarkers; + }, this.highlight = function(re) { + if (!this.$searchHighlight) { + var highlight = new SearchHighlight(null, "ace_selected-word", "text"); + this.$searchHighlight = this.addDynamicMarker(highlight); + } + this.$searchHighlight.setRegexp(re); + }, this.highlightLines = function(startRow, endRow, clazz, inFront) { + "number" != typeof endRow && (clazz = endRow, endRow = startRow), clazz || (clazz = "ace_step"); + var range = new Range(startRow, 0, endRow, 1 / 0); + return range.id = this.addMarker(range, clazz, "fullLine", inFront), range; + }, this.setAnnotations = function(annotations) { + this.$annotations = annotations, this._signal("changeAnnotation", {}); + }, this.getAnnotations = function() { + return this.$annotations || []; + }, this.clearAnnotations = function() { + this.setAnnotations([]); + }, this.$detectNewLine = function(text) { + var match = text.match(/^.*?(\r?\n)/m); + match ? this.$autoNewLine = match[1] : this.$autoNewLine = "\n"; + }, this.getWordRange = function(row, column) { + var line = this.getLine(row), inToken = !1; + if (column > 0 && (inToken = !!line.charAt(column - 1).match(this.tokenRe)), inToken || (inToken = !!line.charAt(column).match(this.tokenRe)), inToken) var re = this.tokenRe; + else if (/^\s+$/.test(line.slice(column - 1, column + 1))) var re = /\s/; + else var re = this.nonTokenRe; + var start = column; + if (start > 0) { + do start--; + while (start >= 0 && line.charAt(start).match(re)) + start++; + } + for(var end = column; end < line.length && line.charAt(end).match(re);)end++; + return new Range(row, start, row, end); + }, this.getAWordRange = function(row, column) { + for(var wordRange = this.getWordRange(row, column), line = this.getLine(wordRange.end.row); line.charAt(wordRange.end.column).match(/[ \t]/);)wordRange.end.column += 1; + return wordRange; + }, this.setNewLineMode = function(newLineMode) { + this.doc.setNewLineMode(newLineMode); + }, this.getNewLineMode = function() { + return this.doc.getNewLineMode(); + }, this.setUseWorker = function(useWorker) { + this.setOption("useWorker", useWorker); + }, this.getUseWorker = function() { + return this.$useWorker; + }, this.onReloadTokenizer = function(e) { + var rows = e.data; + this.bgTokenizer.start(rows.first), this._signal("tokenizerUpdate", e); + }, this.$modes = config.$modes, this.$mode = null, this.$modeId = null, this.setMode = function(mode, cb) { + if (mode && "object" == typeof mode) { + if (mode.getTokenizer) return this.$onChangeMode(mode); + var options = mode, path = options.path; + } else path = mode || "ace/mode/text"; + if (this.$modes["ace/mode/text"] || (this.$modes["ace/mode/text"] = new TextMode()), this.$modes[path] && !options) { + this.$onChangeMode(this.$modes[path]), cb && cb(); + return; + } + this.$modeId = path, config.loadModule([ + "mode", + path + ], (function(m) { + if (this.$modeId !== path) return cb && cb(); + this.$modes[path] && !options ? this.$onChangeMode(this.$modes[path]) : m && m.Mode && (m = new m.Mode(options), options || (this.$modes[path] = m, m.$id = path), this.$onChangeMode(m)), cb && cb(); + }).bind(this)), this.$mode || this.$onChangeMode(this.$modes["ace/mode/text"], !0); + }, this.$onChangeMode = function(mode, $isPlaceholder) { + if ($isPlaceholder || (this.$modeId = mode.$id), this.$mode !== mode) { + var oldMode = this.$mode; + this.$mode = mode, this.$stopWorker(), this.$useWorker && this.$startWorker(); + var tokenizer = mode.getTokenizer(); + if (void 0 !== tokenizer.on) { + var onReloadTokenizer = this.onReloadTokenizer.bind(this); + tokenizer.on("update", onReloadTokenizer); + } + if (this.bgTokenizer) this.bgTokenizer.setTokenizer(tokenizer); + else { + this.bgTokenizer = new BackgroundTokenizer(tokenizer); + var _self = this; + this.bgTokenizer.on("update", function(e) { + _self._signal("tokenizerUpdate", e); + }); + } + this.bgTokenizer.setDocument(this.getDocument()), this.tokenRe = mode.tokenRe, this.nonTokenRe = mode.nonTokenRe, $isPlaceholder || (mode.attachToSession && mode.attachToSession(this), this.$options.wrapMethod.set.call(this, this.$wrapMethod), this.$setFolding(mode.foldingRules), this.bgTokenizer.start(0), this._emit("changeMode", { + oldMode: oldMode, + mode: mode + })); + } + }, this.$stopWorker = function() { + this.$worker && (this.$worker.terminate(), this.$worker = null); + }, this.$startWorker = function() { + try { + this.$worker = this.$mode.createWorker(this); + } catch (e) { + config.warn("Could not load worker", e), this.$worker = null; + } + }, this.getMode = function() { + return this.$mode; + }, this.$scrollTop = 0, this.setScrollTop = function(scrollTop) { + this.$scrollTop === scrollTop || isNaN(scrollTop) || (this.$scrollTop = scrollTop, this._signal("changeScrollTop", scrollTop)); + }, this.getScrollTop = function() { + return this.$scrollTop; + }, this.$scrollLeft = 0, this.setScrollLeft = function(scrollLeft) { + this.$scrollLeft === scrollLeft || isNaN(scrollLeft) || (this.$scrollLeft = scrollLeft, this._signal("changeScrollLeft", scrollLeft)); + }, this.getScrollLeft = function() { + return this.$scrollLeft; + }, this.getScreenWidth = function() { + return (this.$computeWidth(), this.lineWidgets) ? Math.max(this.getLineWidgetMaxWidth(), this.screenWidth) : this.screenWidth; + }, this.getLineWidgetMaxWidth = function() { + if (null != this.lineWidgetsWidth) return this.lineWidgetsWidth; + var width = 0; + return this.lineWidgets.forEach(function(w) { + w && w.screenWidth > width && (width = w.screenWidth); + }), this.lineWidgetWidth = width; + }, this.$computeWidth = function(force) { + if (this.$modified || force) { + if (this.$modified = !1, this.$useWrapMode) return this.screenWidth = this.$wrapLimit; + for(var lines = this.doc.getAllLines(), cache = this.$rowLengthCache, longestScreenLine = 0, foldIndex = 0, foldLine = this.$foldData[foldIndex], foldStart = foldLine ? foldLine.start.row : 1 / 0, len = lines.length, i = 0; i < len; i++){ + if (i > foldStart) { + if ((i = foldLine.end.row + 1) >= len) break; + foldStart = (foldLine = this.$foldData[foldIndex++]) ? foldLine.start.row : 1 / 0; + } + null == cache[i] && (cache[i] = this.$getStringScreenWidth(lines[i])[0]), cache[i] > longestScreenLine && (longestScreenLine = cache[i]); + } + this.screenWidth = longestScreenLine; + } + }, this.getLine = function(row) { + return this.doc.getLine(row); + }, this.getLines = function(firstRow, lastRow) { + return this.doc.getLines(firstRow, lastRow); + }, this.getLength = function() { + return this.doc.getLength(); + }, this.getTextRange = function(range) { + return this.doc.getTextRange(range || this.selection.getRange()); + }, this.insert = function(position, text) { + return this.doc.insert(position, text); + }, this.remove = function(range) { + return this.doc.remove(range); + }, this.removeFullLines = function(firstRow, lastRow) { + return this.doc.removeFullLines(firstRow, lastRow); + }, this.undoChanges = function(deltas, dontSelect) { + if (deltas.length) { + this.$fromUndo = !0; + for(var i = deltas.length - 1; -1 != i; i--){ + var delta = deltas[i]; + "insert" == delta.action || "remove" == delta.action ? this.doc.revertDelta(delta) : delta.folds && this.addFolds(delta.folds); + } + !dontSelect && this.$undoSelect && (deltas.selectionBefore ? this.selection.fromJSON(deltas.selectionBefore) : this.selection.setRange(this.$getUndoSelection(deltas, !0))), this.$fromUndo = !1; + } + }, this.redoChanges = function(deltas, dontSelect) { + if (deltas.length) { + this.$fromUndo = !0; + for(var i = 0; i < deltas.length; i++){ + var delta = deltas[i]; + ("insert" == delta.action || "remove" == delta.action) && this.doc.$safeApplyDelta(delta); + } + !dontSelect && this.$undoSelect && (deltas.selectionAfter ? this.selection.fromJSON(deltas.selectionAfter) : this.selection.setRange(this.$getUndoSelection(deltas, !1))), this.$fromUndo = !1; + } + }, this.setUndoSelect = function(enable) { + this.$undoSelect = enable; + }, this.$getUndoSelection = function(deltas, isUndo) { + function isInsert(delta) { + return isUndo ? "insert" !== delta.action : "insert" === delta.action; + } + for(var range, point, i = 0; i < deltas.length; i++){ + var delta2 = deltas[i]; + if (delta2.start) { + if (!range) { + range = isInsert(delta2) ? Range.fromPoints(delta2.start, delta2.end) : Range.fromPoints(delta2.start, delta2.start); + continue; + } + isInsert(delta2) ? (point = delta2.start, -1 == range.compare(point.row, point.column) && range.setStart(point), point = delta2.end, 1 == range.compare(point.row, point.column) && range.setEnd(point)) : (point = delta2.start, -1 == range.compare(point.row, point.column) && (range = Range.fromPoints(delta2.start, delta2.start))); + } + } + return range; + }, this.replace = function(range, text) { + return this.doc.replace(range, text); + }, this.moveText = function(fromRange, toPosition, copy) { + var text = this.getTextRange(fromRange), folds = this.getFoldsInRange(fromRange), toRange = Range.fromPoints(toPosition, toPosition); + if (!copy) { + this.remove(fromRange); + var rowDiff = fromRange.start.row - fromRange.end.row, collDiff = rowDiff ? -fromRange.end.column : fromRange.start.column - fromRange.end.column; + collDiff && (toRange.start.row == fromRange.end.row && toRange.start.column > fromRange.end.column && (toRange.start.column += collDiff), toRange.end.row == fromRange.end.row && toRange.end.column > fromRange.end.column && (toRange.end.column += collDiff)), rowDiff && toRange.start.row >= fromRange.end.row && (toRange.start.row += rowDiff, toRange.end.row += rowDiff); + } + if (toRange.end = this.insert(toRange.start, text), folds.length) { + var oldStart = fromRange.start, newStart = toRange.start, rowDiff = newStart.row - oldStart.row, collDiff = newStart.column - oldStart.column; + this.addFolds(folds.map(function(x) { + return (x = x.clone()).start.row == oldStart.row && (x.start.column += collDiff), x.end.row == oldStart.row && (x.end.column += collDiff), x.start.row += rowDiff, x.end.row += rowDiff, x; + })); + } + return toRange; + }, this.indentRows = function(startRow, endRow, indentString) { + indentString = indentString.replace(/\t/g, this.getTabString()); + for(var row = startRow; row <= endRow; row++)this.doc.insertInLine({ + row: row, + column: 0 + }, indentString); + }, this.outdentRows = function(range) { + for(var rowRange = range.collapseRows(), deleteRange = new Range(0, 0, 0, 0), size = this.getTabSize(), i = rowRange.start.row; i <= rowRange.end.row; ++i){ + var line = this.getLine(i); + deleteRange.start.row = i, deleteRange.end.row = i; + for(var j = 0; j < size && ' ' == line.charAt(j); ++j); + j < size && '\t' == line.charAt(j) ? (deleteRange.start.column = j, deleteRange.end.column = j + 1) : (deleteRange.start.column = 0, deleteRange.end.column = j), this.remove(deleteRange); + } + }, this.$moveLines = function(firstRow, lastRow, dir) { + if (firstRow = this.getRowFoldStart(firstRow), lastRow = this.getRowFoldEnd(lastRow), dir < 0) { + var row = this.getRowFoldStart(firstRow + dir); + if (row < 0) return 0; + var diff = row - firstRow; + } else if (dir > 0) { + var row = this.getRowFoldEnd(lastRow + dir); + if (row > this.doc.getLength() - 1) return 0; + var diff = row - lastRow; + } else { + firstRow = this.$clipRowToDocument(firstRow); + var diff = (lastRow = this.$clipRowToDocument(lastRow)) - firstRow + 1; + } + var range = new Range(firstRow, 0, lastRow, Number.MAX_VALUE), folds = this.getFoldsInRange(range).map(function(x) { + return x = x.clone(), x.start.row += diff, x.end.row += diff, x; + }), lines = 0 == dir ? this.doc.getLines(firstRow, lastRow) : this.doc.removeFullLines(firstRow, lastRow); + return this.doc.insertFullLines(firstRow + diff, lines), folds.length && this.addFolds(folds), diff; + }, this.moveLinesUp = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, -1); + }, this.moveLinesDown = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, 1); + }, this.duplicateLines = function(firstRow, lastRow) { + return this.$moveLines(firstRow, lastRow, 0); + }, this.$clipRowToDocument = function(row) { + return Math.max(0, Math.min(row, this.doc.getLength() - 1)); + }, this.$clipColumnToRow = function(row, column) { + return column < 0 ? 0 : Math.min(this.doc.getLine(row).length, column); + }, this.$clipPositionToDocument = function(row, column) { + if (column = Math.max(0, column), row < 0) row = 0, column = 0; + else { + var len = this.doc.getLength(); + row >= len ? (row = len - 1, column = this.doc.getLine(len - 1).length) : column = Math.min(this.doc.getLine(row).length, column); + } + return { + row: row, + column: column + }; + }, this.$clipRangeToDocument = function(range) { + range.start.row < 0 ? (range.start.row = 0, range.start.column = 0) : range.start.column = this.$clipColumnToRow(range.start.row, range.start.column); + var len = this.doc.getLength() - 1; + return range.end.row > len ? (range.end.row = len, range.end.column = this.doc.getLine(len).length) : range.end.column = this.$clipColumnToRow(range.end.row, range.end.column), range; + }, this.$wrapLimit = 80, this.$useWrapMode = !1, this.$wrapLimitRange = { + min: null, + max: null + }, this.setUseWrapMode = function(useWrapMode) { + if (useWrapMode != this.$useWrapMode) { + if (this.$useWrapMode = useWrapMode, this.$modified = !0, this.$resetRowCache(0), useWrapMode) { + var len = this.getLength(); + this.$wrapData = Array(len), this.$updateWrapData(0, len - 1); + } + this._signal("changeWrapMode"); + } + }, this.getUseWrapMode = function() { + return this.$useWrapMode; + }, this.setWrapLimitRange = function(min, max) { + (this.$wrapLimitRange.min !== min || this.$wrapLimitRange.max !== max) && (this.$wrapLimitRange = { + min: min, + max: max + }, this.$modified = !0, this.$bidiHandler.markAsDirty(), this.$useWrapMode && this._signal("changeWrapMode")); + }, this.adjustWrapLimit = function(desiredLimit, $printMargin) { + var limits = this.$wrapLimitRange; + limits.max < 0 && (limits = { + min: $printMargin, + max: $printMargin + }); + var wrapLimit = this.$constrainWrapLimit(desiredLimit, limits.min, limits.max); + return wrapLimit != this.$wrapLimit && wrapLimit > 1 && (this.$wrapLimit = wrapLimit, this.$modified = !0, this.$useWrapMode && (this.$updateWrapData(0, this.getLength() - 1), this.$resetRowCache(0), this._signal("changeWrapLimit")), !0); + }, this.$constrainWrapLimit = function(wrapLimit, min, max) { + return min && (wrapLimit = Math.max(min, wrapLimit)), max && (wrapLimit = Math.min(max, wrapLimit)), wrapLimit; + }, this.getWrapLimit = function() { + return this.$wrapLimit; + }, this.setWrapLimit = function(limit) { + this.setWrapLimitRange(limit, limit); + }, this.getWrapLimitRange = function() { + return { + min: this.$wrapLimitRange.min, + max: this.$wrapLimitRange.max + }; + }, this.$updateInternalDataOnChange = function(delta) { + var useWrapMode = this.$useWrapMode, action = delta.action, start = delta.start, end = delta.end, firstRow = start.row, lastRow = end.row, len = lastRow - firstRow, removedFolds = null; + if (this.$updating = !0, 0 != len) if ("remove" === action) { + this[useWrapMode ? "$wrapData" : "$rowLengthCache"].splice(firstRow, len); + var foldLines = this.$foldData; + removedFolds = this.getFoldsInRange(delta), this.removeFolds(removedFolds); + var foldLine = this.getFoldLine(end.row), idx = 0; + if (foldLine) { + foldLine.addRemoveChars(end.row, end.column, start.column - end.column), foldLine.shiftRow(-len); + var foldLineBefore = this.getFoldLine(firstRow); + foldLineBefore && foldLineBefore !== foldLine && (foldLineBefore.merge(foldLine), foldLine = foldLineBefore), idx = foldLines.indexOf(foldLine) + 1; + } + for(; idx < foldLines.length; idx++){ + var foldLine = foldLines[idx]; + foldLine.start.row >= end.row && foldLine.shiftRow(-len); + } + lastRow = firstRow; + } else { + var args = Array(len); + args.unshift(firstRow, 0); + var arr = useWrapMode ? this.$wrapData : this.$rowLengthCache; + arr.splice.apply(arr, args); + var foldLines = this.$foldData, foldLine = this.getFoldLine(firstRow), idx = 0; + if (foldLine) { + var cmp = foldLine.range.compareInside(start.row, start.column); + 0 == cmp ? (foldLine = foldLine.split(start.row, start.column)) && (foldLine.shiftRow(len), foldLine.addRemoveChars(lastRow, 0, end.column - start.column)) : -1 == cmp && (foldLine.addRemoveChars(firstRow, 0, end.column - start.column), foldLine.shiftRow(len)), idx = foldLines.indexOf(foldLine) + 1; + } + for(; idx < foldLines.length; idx++){ + var foldLine = foldLines[idx]; + foldLine.start.row >= firstRow && foldLine.shiftRow(len); + } + } + else { + len = Math.abs(delta.start.column - delta.end.column), "remove" === action && (removedFolds = this.getFoldsInRange(delta), this.removeFolds(removedFolds), len = -len); + var foldLine = this.getFoldLine(firstRow); + foldLine && foldLine.addRemoveChars(firstRow, start.column, len); + } + return useWrapMode && this.$wrapData.length != this.doc.getLength() && console.error("doc.getLength() and $wrapData.length have to be the same!"), this.$updating = !1, useWrapMode ? this.$updateWrapData(firstRow, lastRow) : this.$updateRowLengthCache(firstRow, lastRow), removedFolds; + }, this.$updateRowLengthCache = function(firstRow, lastRow, b) { + this.$rowLengthCache[firstRow] = null, this.$rowLengthCache[lastRow] = null; + }, this.$updateWrapData = function(firstRow, lastRow) { + var tokens, foldLine, lines = this.doc.getAllLines(), tabSize = this.getTabSize(), wrapData = this.$wrapData, wrapLimit = this.$wrapLimit, row1 = firstRow; + for(lastRow = Math.min(lastRow, lines.length - 1); row1 <= lastRow;)(foldLine = this.getFoldLine(row1, foldLine)) ? (tokens = [], foldLine.walk((function(placeholder, row, column, lastColumn) { + var walkTokens; + if (null != placeholder) { + (walkTokens = this.$getDisplayTokens(placeholder, tokens.length))[0] = PLACEHOLDER_START; + for(var i = 1; i < walkTokens.length; i++)walkTokens[i] = PLACEHOLDER_BODY; + } else walkTokens = this.$getDisplayTokens(lines[row].substring(lastColumn, column), tokens.length); + tokens = tokens.concat(walkTokens); + }).bind(this), foldLine.end.row, lines[foldLine.end.row].length + 1), wrapData[foldLine.start.row] = this.$computeWrapSplits(tokens, wrapLimit, tabSize), row1 = foldLine.end.row + 1) : (tokens = this.$getDisplayTokens(lines[row1]), wrapData[row1] = this.$computeWrapSplits(tokens, wrapLimit, tabSize), row1++); + }; + var PLACEHOLDER_START = 3, PLACEHOLDER_BODY = 4; + function isFullWidth(c) { + return !(c < 4352) && (c >= 4352 && c <= 4447 || c >= 4515 && c <= 4519 || c >= 4602 && c <= 4607 || c >= 9001 && c <= 9002 || c >= 11904 && c <= 11929 || c >= 11931 && c <= 12019 || c >= 12032 && c <= 12245 || c >= 12272 && c <= 12283 || c >= 12288 && c <= 12350 || c >= 12353 && c <= 12438 || c >= 12441 && c <= 12543 || c >= 12549 && c <= 12589 || c >= 12593 && c <= 12686 || c >= 12688 && c <= 12730 || c >= 12736 && c <= 12771 || c >= 12784 && c <= 12830 || c >= 12832 && c <= 12871 || c >= 12880 && c <= 13054 || c >= 13056 && c <= 19903 || c >= 19968 && c <= 42124 || c >= 42128 && c <= 42182 || c >= 43360 && c <= 43388 || c >= 44032 && c <= 55203 || c >= 55216 && c <= 55238 || c >= 55243 && c <= 55291 || c >= 63744 && c <= 64255 || c >= 65040 && c <= 65049 || c >= 65072 && c <= 65106 || c >= 65108 && c <= 65126 || c >= 65128 && c <= 65131 || c >= 65281 && c <= 65376 || c >= 65504 && c <= 65510); + } + this.$computeWrapSplits = function(tokens, wrapLimit, tabSize) { + if (0 == tokens.length) return []; + var splits = [], displayLength = tokens.length, lastSplit = 0, lastDocSplit = 0, isCode = this.$wrapAsCode, indentedSoftWrap = this.$indentedSoftWrap, maxIndent = wrapLimit <= Math.max(2 * tabSize, 8) || !1 === indentedSoftWrap ? 0 : Math.floor(wrapLimit / 2); + function addSplit(screenPos) { + for(var len = screenPos - lastSplit, i3 = lastSplit; i3 < screenPos; i3++){ + var ch = tokens[i3]; + (12 === ch || 2 === ch) && (len -= 1); + } + splits.length || (indent = function() { + var indentation = 0; + if (0 === maxIndent) return indentation; + if (indentedSoftWrap) for(var i = 0; i < tokens.length; i++){ + var token = tokens[i]; + if (10 == token) indentation += 1; + else if (11 == token) indentation += tabSize; + else if (12 == token) continue; + else break; + } + return isCode && !1 !== indentedSoftWrap && (indentation += tabSize), Math.min(indentation, maxIndent); + }(), splits.indent = indent), lastDocSplit += len, splits.push(lastDocSplit), lastSplit = screenPos; + } + for(var indent = 0; displayLength - lastSplit > wrapLimit - indent;){ + var split = lastSplit + wrapLimit - indent; + if (tokens[split - 1] >= 10 && tokens[split] >= 10) { + addSplit(split); + continue; + } + if (tokens[split] == PLACEHOLDER_START || tokens[split] == PLACEHOLDER_BODY) { + for(; split != lastSplit - 1 && tokens[split] != PLACEHOLDER_START; split--); + if (split > lastSplit) { + addSplit(split); + continue; + } + for(split = lastSplit + wrapLimit; split < tokens.length && tokens[split] == PLACEHOLDER_BODY; split++); + if (split == tokens.length) break; + addSplit(split); + continue; + } + for(var minSplit = Math.max(split - (wrapLimit - (wrapLimit >> 2)), lastSplit - 1); split > minSplit && tokens[split] < PLACEHOLDER_START;)split--; + if (isCode) { + for(; split > minSplit && tokens[split] < PLACEHOLDER_START;)split--; + for(; split > minSplit && 9 == tokens[split];)split--; + } else for(; split > minSplit && tokens[split] < 10;)split--; + if (split > minSplit) { + addSplit(++split); + continue; + } + 2 == tokens[split = lastSplit + wrapLimit] && split--, addSplit(split - indent); + } + return splits; + }, this.$getDisplayTokens = function(str, offset) { + var tabSize, arr = []; + offset = offset || 0; + for(var i = 0; i < str.length; i++){ + var c = str.charCodeAt(i); + if (9 == c) { + tabSize = this.getScreenTabSize(arr.length + offset), arr.push(11); + for(var n = 1; n < tabSize; n++)arr.push(12); + } else 32 == c ? arr.push(10) : c > 39 && c < 48 || c > 57 && c < 64 ? arr.push(9) : c >= 4352 && isFullWidth(c) ? arr.push(1, 2) : arr.push(1); + } + return arr; + }, this.$getStringScreenWidth = function(str, maxScreenColumn, screenColumn) { + var c, column; + if (0 == maxScreenColumn) return [ + 0, + 0 + ]; + for(null == maxScreenColumn && (maxScreenColumn = 1 / 0), screenColumn = screenColumn || 0, column = 0; column < str.length && (9 == (c = str.charCodeAt(column)) ? screenColumn += this.getScreenTabSize(screenColumn) : c >= 4352 && isFullWidth(c) ? screenColumn += 2 : screenColumn += 1, !(screenColumn > maxScreenColumn)); column++); + return [ + screenColumn, + column + ]; + }, this.lineWidgets = null, this.getRowLength = function(row) { + var h = 1; + return (this.lineWidgets && (h += this.lineWidgets[row] && this.lineWidgets[row].rowCount || 0), this.$useWrapMode && this.$wrapData[row]) ? this.$wrapData[row].length + h : h; + }, this.getRowLineCount = function(row) { + return this.$useWrapMode && this.$wrapData[row] ? this.$wrapData[row].length + 1 : 1; + }, this.getRowWrapIndent = function(screenRow) { + if (!this.$useWrapMode) return 0; + var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE), splits = this.$wrapData[pos.row]; + return splits.length && splits[0] < pos.column ? splits.indent : 0; + }, this.getScreenLastRowColumn = function(screenRow) { + var pos = this.screenToDocumentPosition(screenRow, Number.MAX_VALUE); + return this.documentToScreenColumn(pos.row, pos.column); + }, this.getDocumentLastRowColumn = function(docRow, docColumn) { + var screenRow = this.documentToScreenRow(docRow, docColumn); + return this.getScreenLastRowColumn(screenRow); + }, this.getDocumentLastRowColumnPosition = function(docRow, docColumn) { + var screenRow = this.documentToScreenRow(docRow, docColumn); + return this.screenToDocumentPosition(screenRow, Number.MAX_VALUE / 10); + }, this.getRowSplitData = function(row) { + if (this.$useWrapMode) return this.$wrapData[row]; + }, this.getScreenTabSize = function(screenColumn) { + return this.$tabSize - (screenColumn % this.$tabSize | 0); + }, this.screenToDocumentRow = function(screenRow, screenColumn) { + return this.screenToDocumentPosition(screenRow, screenColumn).row; + }, this.screenToDocumentColumn = function(screenRow, screenColumn) { + return this.screenToDocumentPosition(screenRow, screenColumn).column; + }, this.screenToDocumentPosition = function(screenRow, screenColumn, offsetX) { + if (screenRow < 0) return { + row: 0, + column: 0 + }; + var line, column, docRow = 0, docColumn = 0, row = 0, rowLength = 0, rowCache = this.$screenRowCache, i = this.$getRowCacheIndex(rowCache, screenRow), l = rowCache.length; + if (l && i >= 0) var row = rowCache[i], docRow = this.$docRowCache[i], doCache = screenRow > rowCache[l - 1]; + else var doCache = !l; + for(var maxRow = this.getLength() - 1, foldLine = this.getNextFoldLine(docRow), foldStart = foldLine ? foldLine.start.row : 1 / 0; row <= screenRow && !(row + (rowLength = this.getRowLength(docRow)) > screenRow) && !(docRow >= maxRow);)row += rowLength, docRow++, docRow > foldStart && (docRow = foldLine.end.row + 1, foldStart = (foldLine = this.getNextFoldLine(docRow, foldLine)) ? foldLine.start.row : 1 / 0), doCache && (this.$docRowCache.push(docRow), this.$screenRowCache.push(row)); + if (foldLine && foldLine.start.row <= docRow) line = this.getFoldDisplayLine(foldLine), docRow = foldLine.start.row; + else { + if (row + rowLength <= screenRow || docRow > maxRow) return { + row: maxRow, + column: this.getLine(maxRow).length + }; + line = this.getLine(docRow), foldLine = null; + } + var wrapIndent = 0, splitIndex = Math.floor(screenRow - row); + if (this.$useWrapMode) { + var splits = this.$wrapData[docRow]; + splits && (column = splits[splitIndex], splitIndex > 0 && splits.length && (wrapIndent = splits.indent, docColumn = splits[splitIndex - 1] || splits[splits.length - 1], line = line.substring(docColumn))); + } + return (void 0 !== offsetX && this.$bidiHandler.isBidiRow(row + splitIndex, docRow, splitIndex) && (screenColumn = this.$bidiHandler.offsetToCol(offsetX)), docColumn += this.$getStringScreenWidth(line, screenColumn - wrapIndent)[1], this.$useWrapMode && docColumn >= column && (docColumn = column - 1), foldLine) ? foldLine.idxToPosition(docColumn) : { + row: docRow, + column: docColumn + }; + }, this.documentToScreenPosition = function(docRow, docColumn) { + if (void 0 === docColumn) var pos = this.$clipPositionToDocument(docRow.row, docRow.column); + else pos = this.$clipPositionToDocument(docRow, docColumn); + docRow = pos.row, docColumn = pos.column; + var screenRow = 0, foldStartRow = null, fold = null; + (fold = this.getFoldAt(docRow, docColumn, 1)) && (docRow = fold.start.row, docColumn = fold.start.column); + var rowEnd, row = 0, rowCache = this.$docRowCache, i = this.$getRowCacheIndex(rowCache, docRow), l = rowCache.length; + if (l && i >= 0) var row = rowCache[i], screenRow = this.$screenRowCache[i], doCache = docRow > rowCache[l - 1]; + else var doCache = !l; + for(var foldLine = this.getNextFoldLine(row), foldStart = foldLine ? foldLine.start.row : 1 / 0; row < docRow;){ + if (row >= foldStart) { + if ((rowEnd = foldLine.end.row + 1) > docRow) break; + foldStart = (foldLine = this.getNextFoldLine(rowEnd, foldLine)) ? foldLine.start.row : 1 / 0; + } else rowEnd = row + 1; + screenRow += this.getRowLength(row), row = rowEnd, doCache && (this.$docRowCache.push(row), this.$screenRowCache.push(screenRow)); + } + var textLine = ""; + foldLine && row >= foldStart ? (textLine = this.getFoldDisplayLine(foldLine, docRow, docColumn), foldStartRow = foldLine.start.row) : (textLine = this.getLine(docRow).substring(0, docColumn), foldStartRow = docRow); + var wrapIndent = 0; + if (this.$useWrapMode) { + var wrapRow = this.$wrapData[foldStartRow]; + if (wrapRow) { + for(var screenRowOffset = 0; textLine.length >= wrapRow[screenRowOffset];)screenRow++, screenRowOffset++; + textLine = textLine.substring(wrapRow[screenRowOffset - 1] || 0, textLine.length), wrapIndent = screenRowOffset > 0 ? wrapRow.indent : 0; + } + } + return this.lineWidgets && this.lineWidgets[row] && this.lineWidgets[row].rowsAbove && (screenRow += this.lineWidgets[row].rowsAbove), { + row: screenRow, + column: wrapIndent + this.$getStringScreenWidth(textLine)[0] + }; + }, this.documentToScreenColumn = function(row, docColumn) { + return this.documentToScreenPosition(row, docColumn).column; + }, this.documentToScreenRow = function(docRow, docColumn) { + return this.documentToScreenPosition(docRow, docColumn).row; + }, this.getScreenLength = function() { + var screenRows = 0, fold = null; + if (this.$useWrapMode) for(var lastRow = this.$wrapData.length, row = 0, i = 0, fold = this.$foldData[i++], foldStart = fold ? fold.start.row : 1 / 0; row < lastRow;){ + var splits = this.$wrapData[row]; + screenRows += splits ? splits.length + 1 : 1, row++, row > foldStart && (row = fold.end.row + 1, foldStart = (fold = this.$foldData[i++]) ? fold.start.row : 1 / 0); + } + else { + screenRows = this.getLength(); + for(var foldData = this.$foldData, i = 0; i < foldData.length; i++)screenRows -= (fold = foldData[i]).end.row - fold.start.row; + } + return this.lineWidgets && (screenRows += this.$getWidgetScreenLength()), screenRows; + }, this.$setFontMetrics = function(fm) { + this.$enableVarChar && (this.$getStringScreenWidth = function(str, maxScreenColumn, screenColumn) { + var c, column; + if (0 === maxScreenColumn) return [ + 0, + 0 + ]; + for(maxScreenColumn || (maxScreenColumn = 1 / 0), screenColumn = screenColumn || 0, column = 0; column < str.length && ("\t" === (c = str.charAt(column)) ? screenColumn += this.getScreenTabSize(screenColumn) : screenColumn += fm.getCharacterWidth(c), !(screenColumn > maxScreenColumn)); column++); + return [ + screenColumn, + column + ]; + }); + }, this.destroy = function() { + this.bgTokenizer && (this.bgTokenizer.setDocument(null), this.bgTokenizer = null), this.$stopWorker(), this.removeAllListeners(), this.doc && this.doc.off("change", this.$onChange), this.selection.detach(); + }, this.isFullWidth = isFullWidth; + }).call(EditSession.prototype), require("./edit_session/folding").Folding.call(EditSession.prototype), require("./edit_session/bracket_match").BracketMatch.call(EditSession.prototype), config.defineOptions(EditSession.prototype, "session", { + wrap: { + set: function(value) { + if (value && "off" != value ? "free" == value ? value = !0 : "printMargin" == value ? value = -1 : "string" == typeof value && (value = parseInt(value, 10) || !1) : value = !1, this.$wrap != value) if (this.$wrap = value, value) { + var col = "number" == typeof value ? value : null; + this.setWrapLimitRange(col, col), this.setUseWrapMode(!0); + } else this.setUseWrapMode(!1); + }, + get: function() { + return this.getUseWrapMode() ? -1 == this.$wrap ? "printMargin" : this.getWrapLimitRange().min ? this.$wrap : "free" : "off"; + }, + handlesSet: !0 + }, + wrapMethod: { + set: function(val) { + (val = "auto" == val ? "text" != this.$mode.type : "text" != val) != this.$wrapAsCode && (this.$wrapAsCode = val, this.$useWrapMode && (this.$useWrapMode = !1, this.setUseWrapMode(!0))); + }, + initialValue: "auto" + }, + indentedSoftWrap: { + set: function() { + this.$useWrapMode && (this.$useWrapMode = !1, this.setUseWrapMode(!0)); + }, + initialValue: !0 + }, + firstLineNumber: { + set: function() { + this._signal("changeBreakpoint"); + }, + initialValue: 1 + }, + useWorker: { + set: function(useWorker) { + this.$useWorker = useWorker, this.$stopWorker(), useWorker && this.$startWorker(); + }, + initialValue: !0 + }, + useSoftTabs: { + initialValue: !0 + }, + tabSize: { + set: function(tabSize) { + (tabSize = parseInt(tabSize)) > 0 && this.$tabSize !== tabSize && (this.$modified = !0, this.$rowLengthCache = [], this.$tabSize = tabSize, this._signal("changeTabSize")); + }, + initialValue: 4, + handlesSet: !0 + }, + navigateWithinSoftTabs: { + initialValue: !1 + }, + foldStyle: { + set: function(val) { + this.setFoldStyle(val); + }, + handlesSet: !0 + }, + overwrite: { + set: function(val) { + this._signal("changeOverwrite"); + }, + initialValue: !1 + }, + newLineMode: { + set: function(val) { + this.doc.setNewLineMode(val); + }, + get: function() { + return this.doc.getNewLineMode(); + }, + handlesSet: !0 + }, + mode: { + set: function(val) { + this.setMode(val); + }, + get: function() { + return this.$modeId; + }, + handlesSet: !0 + } + }), exports.EditSession = EditSession; + }), ace.define("ace/search", [ + "require", + "exports", + "module", + "ace/lib/lang", + "ace/lib/oop", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var lang = require("./lib/lang"), oop = require("./lib/oop"), Range = require("./range").Range, Search = function() { + this.$options = {}; + }; + (function() { + this.set = function(options) { + return oop.mixin(this.$options, options), this; + }, this.getOptions = function() { + return lang.copyObject(this.$options); + }, this.setOptions = function(options) { + this.$options = options; + }, this.find = function(session) { + var options = this.$options, iterator = this.$matchIterator(session, options); + if (!iterator) return !1; + var firstRange = null; + return iterator.forEach(function(sr, sc, er, ec) { + return firstRange = new Range(sr, sc, er, ec), !(sc == ec && options.start && options.start.start && !1 != options.skipCurrent && firstRange.isEqual(options.start)) || (firstRange = null, !1); + }), firstRange; + }, this.findAll = function(session) { + var options = this.$options; + if (!options.needle) return []; + this.$assembleRegExp(options); + var range = options.range, lines = range ? session.getLines(range.start.row, range.end.row) : session.doc.getAllLines(), ranges = [], re = options.re; + if (options.$isMultiLine) { + var prevRange, len = re.length, maxRow = lines.length - len; + outer: for(var row = re.offset || 0; row <= maxRow; row++){ + for(var j = 0; j < len; j++)if (-1 == lines[row + j].search(re[j])) continue outer; + var startLine = lines[row], line = lines[row + len - 1], startIndex = startLine.length - startLine.match(re[0])[0].length, endIndex = line.match(re[len - 1])[0].length; + prevRange && prevRange.end.row === row && prevRange.end.column > startIndex || (ranges.push(prevRange = new Range(row, startIndex, row + len - 1, endIndex)), len > 2 && (row = row + len - 2)); + } + } else for(var i = 0; i < lines.length; i++)for(var matches = lang.getMatchOffsets(lines[i], re), j = 0; j < matches.length; j++){ + var match = matches[j]; + ranges.push(new Range(i, match.offset, i, match.offset + match.length)); + } + if (range) { + for(var startColumn = range.start.column, endColumn = range.start.column, i = 0, j = ranges.length - 1; i < j && ranges[i].start.column < startColumn && ranges[i].start.row == range.start.row;)i++; + for(; i < j && ranges[j].end.column > endColumn && ranges[j].end.row == range.end.row;)j--; + for(ranges = ranges.slice(i, j + 1), i = 0, j = ranges.length; i < j; i++)ranges[i].start.row += range.start.row, ranges[i].end.row += range.start.row; + } + return ranges; + }, this.replace = function(input, replacement) { + var options = this.$options, re = this.$assembleRegExp(options); + if (options.$isMultiLine) return replacement; + if (re) { + var match = re.exec(input); + if (!match || match[0].length != input.length) return null; + if (replacement = input.replace(re, replacement), options.preserveCase) { + replacement = replacement.split(""); + for(var i = Math.min(input.length, input.length); i--;){ + var ch = input[i]; + ch && ch.toLowerCase() != ch ? replacement[i] = replacement[i].toUpperCase() : replacement[i] = replacement[i].toLowerCase(); + } + replacement = replacement.join(""); + } + return replacement; + } + }, this.$assembleRegExp = function(options1, $disableFakeMultiline) { + if (options1.needle instanceof RegExp) return options1.re = options1.needle; + var needle1 = options1.needle; + if (!options1.needle) return options1.re = !1; + options1.regExp || (needle1 = lang.escapeRegExp(needle1)), options1.wholeWord && (needle1 = function(needle, options) { + function wordBoundary(c) { + return /\w/.test(c) || options.regExp ? "\\b" : ""; + } + return wordBoundary(needle[0]) + needle + wordBoundary(needle[needle.length - 1]); + }(needle1, options1)); + var modifier = options1.caseSensitive ? "gm" : "gmi"; + if (options1.$isMultiLine = !$disableFakeMultiline && /[\n\r]/.test(needle1), options1.$isMultiLine) return options1.re = this.$assembleMultilineRegExp(needle1, modifier); + try { + var re = new RegExp(needle1, modifier); + } catch (e) { + re = !1; + } + return options1.re = re; + }, this.$assembleMultilineRegExp = function(needle, modifier) { + for(var parts = needle.replace(/\r\n|\r|\n/g, "$\n^").split("\n"), re = [], i = 0; i < parts.length; i++)try { + re.push(new RegExp(parts[i], modifier)); + } catch (e) { + return !1; + } + return re; + }, this.$matchIterator = function(session, options) { + var re = this.$assembleRegExp(options); + if (!re) return !1; + var backwards = !0 == options.backwards, skipCurrent = !1 != options.skipCurrent, range = options.range, start = options.start; + start || (start = range ? range[backwards ? "end" : "start"] : session.selection.getRange()), start.start && (start = start[skipCurrent != backwards ? "end" : "start"]); + var firstRow = range ? range.start.row : 0, lastRow = range ? range.end.row : session.getLength() - 1; + if (backwards) var forEach = function(callback) { + var row = start.row; + if (!forEachInLine(row, start.column, callback)) { + for(row--; row >= firstRow; row--)if (forEachInLine(row, Number.MAX_VALUE, callback)) return; + if (!1 != options.wrap) { + for(row = lastRow, firstRow = start.row; row >= firstRow; row--)if (forEachInLine(row, Number.MAX_VALUE, callback)) return; + } + } + }; + else var forEach = function(callback) { + var row = start.row; + if (!forEachInLine(row, start.column, callback)) { + for(row += 1; row <= lastRow; row++)if (forEachInLine(row, 0, callback)) return; + if (!1 != options.wrap) { + for(row = firstRow, lastRow = start.row; row <= lastRow; row++)if (forEachInLine(row, 0, callback)) return; + } + } + }; + if (options.$isMultiLine) var len = re.length, forEachInLine = function(row, offset, callback) { + var startRow = backwards ? row - len + 1 : row; + if (!(startRow < 0 || startRow + len > session.getLength())) { + var line = session.getLine(startRow), startIndex = line.search(re[0]); + if ((backwards || !(startIndex < offset)) && -1 !== startIndex) { + for(var i = 1; i < len; i++)if (-1 == (line = session.getLine(startRow + i)).search(re[i])) return; + var endIndex = line.match(re[len - 1])[0].length; + if ((!backwards || !(endIndex > offset)) && callback(startRow, startIndex, startRow + len - 1, endIndex)) return !0; + } + } + }; + else if (backwards) var forEachInLine = function(row, endIndex, callback) { + var m, line = session.getLine(row), matches = [], last = 0; + for(re.lastIndex = 0; m = re.exec(line);){ + var length = m[0].length; + if (last = m.index, !length) { + if (last >= line.length) break; + re.lastIndex = last += 1; + } + if (m.index + length > endIndex) break; + matches.push(m.index, length); + } + for(var i = matches.length - 1; i >= 0; i -= 2){ + var column = matches[i - 1], length = matches[i]; + if (callback(row, column, row, column + length)) return !0; + } + }; + else var forEachInLine = function(row, startIndex, callback) { + var last, m, line = session.getLine(row); + for(re.lastIndex = startIndex; m = re.exec(line);){ + var length = m[0].length; + if (callback(row, last = m.index, row, last + length)) return !0; + if (!length && (re.lastIndex = last += 1, last >= line.length)) return !1; + } + }; + return { + forEach: forEach + }; + }; + }).call(Search.prototype), exports.Search = Search; + }), ace.define("ace/keyboard/hash_handler", [ + "require", + "exports", + "module", + "ace/lib/keys", + "ace/lib/useragent" + ], function(require, exports, module) { + "use strict"; + var keyUtil = require("../lib/keys"), useragent = require("../lib/useragent"), KEY_MODS = keyUtil.KEY_MODS; + function HashHandler(config, platform) { + this.platform = platform || (useragent.isMac ? "mac" : "win"), this.commands = {}, this.commandKeyBinding = {}, this.addCommands(config), this.$singleCommand = !0; + } + function MultiHashHandler(config, platform) { + HashHandler.call(this, config, platform), this.$singleCommand = !1; + } + MultiHashHandler.prototype = HashHandler.prototype, (function() { + function getPosition(command) { + return "object" == typeof command && command.bindKey && command.bindKey.position || (command.isDefault ? -100 : 0); + } + this.addCommand = function(command) { + this.commands[command.name] && this.removeCommand(command), this.commands[command.name] = command, command.bindKey && this._buildKeyHash(command); + }, this.removeCommand = function(command, keepCommand) { + var name = command && ('string' == typeof command ? command : command.name); + command = this.commands[name], keepCommand || delete this.commands[name]; + var ckb = this.commandKeyBinding; + for(var keyId in ckb){ + var cmdGroup = ckb[keyId]; + if (cmdGroup == command) delete ckb[keyId]; + else if (Array.isArray(cmdGroup)) { + var i = cmdGroup.indexOf(command); + -1 != i && (cmdGroup.splice(i, 1), 1 == cmdGroup.length && (ckb[keyId] = cmdGroup[0])); + } + } + }, this.bindKey = function(key, command, position) { + if ("object" == typeof key && key && (void 0 == position && (position = key.position), key = key[this.platform]), key) { + if ("function" == typeof command) return this.addCommand({ + exec: command, + bindKey: key, + name: command.name || key + }); + key.split("|").forEach(function(keyPart1) { + var chain = ""; + if (-1 != keyPart1.indexOf(" ")) { + var parts = keyPart1.split(/\s+/); + keyPart1 = parts.pop(), parts.forEach(function(keyPart) { + var binding = this.parseKeys(keyPart), id = KEY_MODS[binding.hashId] + binding.key; + chain += (chain ? " " : "") + id, this._addCommandToBinding(chain, "chainKeys"); + }, this), chain += " "; + } + var binding1 = this.parseKeys(keyPart1), id1 = KEY_MODS[binding1.hashId] + binding1.key; + this._addCommandToBinding(chain + id1, command, position); + }, this); + } + }, this._addCommandToBinding = function(keyId, command, position) { + var i, ckb = this.commandKeyBinding; + if (command) if (!ckb[keyId] || this.$singleCommand) ckb[keyId] = command; + else { + Array.isArray(ckb[keyId]) ? -1 != (i = ckb[keyId].indexOf(command)) && ckb[keyId].splice(i, 1) : ckb[keyId] = [ + ckb[keyId] + ], "number" != typeof position && (position = getPosition(command)); + var commands = ckb[keyId]; + for(i = 0; i < commands.length && !(getPosition(commands[i]) > position); i++); + commands.splice(i, 0, command); + } + else delete ckb[keyId]; + }, this.addCommands = function(commands) { + commands && Object.keys(commands).forEach(function(name) { + var command = commands[name]; + if (command) { + if ("string" == typeof command) return this.bindKey(command, name); + "function" == typeof command && (command = { + exec: command + }), "object" == typeof command && (command.name || (command.name = name), this.addCommand(command)); + } + }, this); + }, this.removeCommands = function(commands) { + Object.keys(commands).forEach(function(name) { + this.removeCommand(commands[name]); + }, this); + }, this.bindKeys = function(keyList) { + Object.keys(keyList).forEach(function(key) { + this.bindKey(key, keyList[key]); + }, this); + }, this._buildKeyHash = function(command) { + this.bindKey(command.bindKey, command); + }, this.parseKeys = function(keys) { + var parts = keys.toLowerCase().split(/[\-\+]([\-\+])?/).filter(function(x) { + return x; + }), key = parts.pop(), keyCode = keyUtil[key]; + if (keyUtil.FUNCTION_KEYS[keyCode]) key = keyUtil.FUNCTION_KEYS[keyCode].toLowerCase(); + else if (!parts.length) return { + key: key, + hashId: -1 + }; + else if (1 == parts.length && "shift" == parts[0]) return { + key: key.toUpperCase(), + hashId: -1 + }; + for(var hashId = 0, i = parts.length; i--;){ + var modifier = keyUtil.KEY_MODS[parts[i]]; + if (null == modifier) return "undefined" != typeof console && console.error("invalid modifier " + parts[i] + " in " + keys), !1; + hashId |= modifier; + } + return { + key: key, + hashId: hashId + }; + }, this.findKeyCommand = function(hashId, keyString) { + var key = KEY_MODS[hashId] + keyString; + return this.commandKeyBinding[key]; + }, this.handleKeyboard = function(data, hashId, keyString, keyCode) { + if (!(keyCode < 0)) { + var key = KEY_MODS[hashId] + keyString, command = this.commandKeyBinding[key]; + return (data.$keyChain && (data.$keyChain += " " + key, command = this.commandKeyBinding[data.$keyChain] || command), command && ("chainKeys" == command || "chainKeys" == command[command.length - 1])) ? (data.$keyChain = data.$keyChain || key, { + command: "null" + }) : (data.$keyChain && (hashId && 4 != hashId || 1 != keyString.length ? (-1 == hashId || keyCode > 0) && (data.$keyChain = "") : data.$keyChain = data.$keyChain.slice(0, -key.length - 1)), { + command: command + }); + } + }, this.getStatusText = function(editor, data) { + return data.$keyChain || ""; + }; + }).call(HashHandler.prototype), exports.HashHandler = HashHandler, exports.MultiHashHandler = MultiHashHandler; + }), ace.define("ace/commands/command_manager", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/keyboard/hash_handler", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "use strict"; + var oop = require("../lib/oop"), MultiHashHandler = require("../keyboard/hash_handler").MultiHashHandler, EventEmitter = require("../lib/event_emitter").EventEmitter, CommandManager = function(platform, commands) { + MultiHashHandler.call(this, commands, platform), this.byName = this.commands, this.setDefaultHandler("exec", function(e) { + return e.command.exec(e.editor, e.args || {}); + }); + }; + oop.inherits(CommandManager, MultiHashHandler), (function() { + oop.implement(this, EventEmitter), this.exec = function(command, editor, args) { + if (Array.isArray(command)) { + for(var i = command.length; i--;)if (this.exec(command[i], editor, args)) return !0; + return !1; + } + if ("string" == typeof command && (command = this.commands[command]), !command) return !1; + if (editor && editor.$readOnly && !command.readOnly) return !1; + if (!1 != this.$checkCommandState && command.isAvailable && !command.isAvailable(editor)) return !1; + var e = { + editor: editor, + command: command, + args: args + }; + return e.returnValue = this._emit("exec", e), this._signal("afterExec", e), !1 !== e.returnValue; + }, this.toggleRecording = function(editor) { + if (!this.$inReplay) return (editor && editor._emit("changeStatus"), this.recording) ? (this.macro.pop(), this.off("exec", this.$addCommandToMacro), this.macro.length || (this.macro = this.oldMacro), this.recording = !1) : (this.$addCommandToMacro || (this.$addCommandToMacro = (function(e) { + this.macro.push([ + e.command, + e.args + ]); + }).bind(this)), this.oldMacro = this.macro, this.macro = [], this.on("exec", this.$addCommandToMacro), this.recording = !0); + }, this.replay = function(editor) { + if (!this.$inReplay && this.macro) { + if (this.recording) return this.toggleRecording(editor); + try { + this.$inReplay = !0, this.macro.forEach(function(x) { + "string" == typeof x ? this.exec(x, editor) : this.exec(x[0], editor, x[1]); + }, this); + } finally{ + this.$inReplay = !1; + } + } + }, this.trimMacro = function(m) { + return m.map(function(x) { + return "string" != typeof x[0] && (x[0] = x[0].name), x[1] || (x = x[0]), x; + }); + }; + }).call(CommandManager.prototype), exports.CommandManager = CommandManager; + }), ace.define("ace/commands/default_commands", [ + "require", + "exports", + "module", + "ace/lib/lang", + "ace/config", + "ace/range" + ], function(require, exports, module6) { + "use strict"; + var lang = require("../lib/lang"), config = require("../config"), Range = require("../range").Range; + function bindKey(win, mac) { + return { + win: win, + mac: mac + }; + } + exports.commands = [ + { + name: "showSettingsMenu", + description: "Show settings menu", + bindKey: bindKey("Ctrl-,", "Command-,"), + exec: function(editor) { + config.loadModule("ace/ext/settings_menu", function(module) { + module.init(editor), editor.showSettingsMenu(); + }); + }, + readOnly: !0 + }, + { + name: "goToNextError", + description: "Go to next error", + bindKey: bindKey("Alt-E", "F4"), + exec: function(editor) { + config.loadModule("./ext/error_marker", function(module) { + module.showErrorMarker(editor, 1); + }); + }, + scrollIntoView: "animate", + readOnly: !0 + }, + { + name: "goToPreviousError", + description: "Go to previous error", + bindKey: bindKey("Alt-Shift-E", "Shift-F4"), + exec: function(editor) { + config.loadModule("./ext/error_marker", function(module) { + module.showErrorMarker(editor, -1); + }); + }, + scrollIntoView: "animate", + readOnly: !0 + }, + { + name: "selectall", + description: "Select all", + bindKey: bindKey("Ctrl-A", "Command-A"), + exec: function(editor) { + editor.selectAll(); + }, + readOnly: !0 + }, + { + name: "centerselection", + description: "Center selection", + bindKey: bindKey(null, "Ctrl-L"), + exec: function(editor) { + editor.centerSelection(); + }, + readOnly: !0 + }, + { + name: "gotoline", + description: "Go to line...", + bindKey: bindKey("Ctrl-L", "Command-L"), + exec: function(editor, line) { + "number" != typeof line || isNaN(line) || editor.gotoLine(line), editor.prompt({ + $type: "gotoLine" + }); + }, + readOnly: !0 + }, + { + name: "fold", + bindKey: bindKey("Alt-L|Ctrl-F1", "Command-Alt-L|Command-F1"), + exec: function(editor) { + editor.session.toggleFold(!1); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "unfold", + bindKey: bindKey("Alt-Shift-L|Ctrl-Shift-F1", "Command-Alt-Shift-L|Command-Shift-F1"), + exec: function(editor) { + editor.session.toggleFold(!0); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "toggleFoldWidget", + description: "Toggle fold widget", + bindKey: bindKey("F2", "F2"), + exec: function(editor) { + editor.session.toggleFoldWidget(); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "toggleParentFoldWidget", + description: "Toggle parent fold widget", + bindKey: bindKey("Alt-F2", "Alt-F2"), + exec: function(editor) { + editor.session.toggleFoldWidget(!0); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "foldall", + description: "Fold all", + bindKey: bindKey(null, "Ctrl-Command-Option-0"), + exec: function(editor) { + editor.session.foldAll(); + }, + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "foldAllComments", + description: "Fold all comments", + bindKey: bindKey(null, "Ctrl-Command-Option-0"), + exec: function(editor) { + editor.session.foldAllComments(); + }, + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "foldOther", + description: "Fold other", + bindKey: bindKey("Alt-0", "Command-Option-0"), + exec: function(editor) { + editor.session.foldAll(), editor.session.unfold(editor.selection.getAllRanges()); + }, + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "unfoldall", + description: "Unfold all", + bindKey: bindKey("Alt-Shift-0", "Command-Option-Shift-0"), + exec: function(editor) { + editor.session.unfold(); + }, + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "findnext", + description: "Find next", + bindKey: bindKey("Ctrl-K", "Command-G"), + exec: function(editor) { + editor.findNext(); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "findprevious", + description: "Find previous", + bindKey: bindKey("Ctrl-Shift-K", "Command-Shift-G"), + exec: function(editor) { + editor.findPrevious(); + }, + multiSelectAction: "forEach", + scrollIntoView: "center", + readOnly: !0 + }, + { + name: "selectOrFindNext", + description: "Select or find next", + bindKey: bindKey("Alt-K", "Ctrl-G"), + exec: function(editor) { + editor.selection.isEmpty() ? editor.selection.selectWord() : editor.findNext(); + }, + readOnly: !0 + }, + { + name: "selectOrFindPrevious", + description: "Select or find previous", + bindKey: bindKey("Alt-Shift-K", "Ctrl-Shift-G"), + exec: function(editor) { + editor.selection.isEmpty() ? editor.selection.selectWord() : editor.findPrevious(); + }, + readOnly: !0 + }, + { + name: "find", + description: "Find", + bindKey: bindKey("Ctrl-F", "Command-F"), + exec: function(editor) { + config.loadModule("ace/ext/searchbox", function(e) { + e.Search(editor); + }); + }, + readOnly: !0 + }, + { + name: "overwrite", + description: "Overwrite", + bindKey: "Insert", + exec: function(editor) { + editor.toggleOverwrite(); + }, + readOnly: !0 + }, + { + name: "selecttostart", + description: "Select to start", + bindKey: bindKey("Ctrl-Shift-Home", "Command-Shift-Home|Command-Shift-Up"), + exec: function(editor) { + editor.getSelection().selectFileStart(); + }, + multiSelectAction: "forEach", + readOnly: !0, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" + }, + { + name: "gotostart", + description: "Go to start", + bindKey: bindKey("Ctrl-Home", "Command-Home|Command-Up"), + exec: function(editor) { + editor.navigateFileStart(); + }, + multiSelectAction: "forEach", + readOnly: !0, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" + }, + { + name: "selectup", + description: "Select up", + bindKey: bindKey("Shift-Up", "Shift-Up|Ctrl-Shift-P"), + exec: function(editor) { + editor.getSelection().selectUp(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "golineup", + description: "Go line up", + bindKey: bindKey("Up", "Up|Ctrl-P"), + exec: function(editor, args) { + editor.navigateUp(args.times); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selecttoend", + description: "Select to end", + bindKey: bindKey("Ctrl-Shift-End", "Command-Shift-End|Command-Shift-Down"), + exec: function(editor) { + editor.getSelection().selectFileEnd(); + }, + multiSelectAction: "forEach", + readOnly: !0, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" + }, + { + name: "gotoend", + description: "Go to end", + bindKey: bindKey("Ctrl-End", "Command-End|Command-Down"), + exec: function(editor) { + editor.navigateFileEnd(); + }, + multiSelectAction: "forEach", + readOnly: !0, + scrollIntoView: "animate", + aceCommandGroup: "fileJump" + }, + { + name: "selectdown", + description: "Select down", + bindKey: bindKey("Shift-Down", "Shift-Down|Ctrl-Shift-N"), + exec: function(editor) { + editor.getSelection().selectDown(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "golinedown", + description: "Go line down", + bindKey: bindKey("Down", "Down|Ctrl-N"), + exec: function(editor, args) { + editor.navigateDown(args.times); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectwordleft", + description: "Select word left", + bindKey: bindKey("Ctrl-Shift-Left", "Option-Shift-Left"), + exec: function(editor) { + editor.getSelection().selectWordLeft(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotowordleft", + description: "Go to word left", + bindKey: bindKey("Ctrl-Left", "Option-Left"), + exec: function(editor) { + editor.navigateWordLeft(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selecttolinestart", + description: "Select to line start", + bindKey: bindKey("Alt-Shift-Left", "Command-Shift-Left|Ctrl-Shift-A"), + exec: function(editor) { + editor.getSelection().selectLineStart(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotolinestart", + description: "Go to line start", + bindKey: bindKey("Alt-Left|Home", "Command-Left|Home|Ctrl-A"), + exec: function(editor) { + editor.navigateLineStart(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectleft", + description: "Select left", + bindKey: bindKey("Shift-Left", "Shift-Left|Ctrl-Shift-B"), + exec: function(editor) { + editor.getSelection().selectLeft(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotoleft", + description: "Go to left", + bindKey: bindKey("Left", "Left|Ctrl-B"), + exec: function(editor, args) { + editor.navigateLeft(args.times); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectwordright", + description: "Select word right", + bindKey: bindKey("Ctrl-Shift-Right", "Option-Shift-Right"), + exec: function(editor) { + editor.getSelection().selectWordRight(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotowordright", + description: "Go to word right", + bindKey: bindKey("Ctrl-Right", "Option-Right"), + exec: function(editor) { + editor.navigateWordRight(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selecttolineend", + description: "Select to line end", + bindKey: bindKey("Alt-Shift-Right", "Command-Shift-Right|Shift-End|Ctrl-Shift-E"), + exec: function(editor) { + editor.getSelection().selectLineEnd(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotolineend", + description: "Go to line end", + bindKey: bindKey("Alt-Right|End", "Command-Right|End|Ctrl-E"), + exec: function(editor) { + editor.navigateLineEnd(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectright", + description: "Select right", + bindKey: bindKey("Shift-Right", "Shift-Right"), + exec: function(editor) { + editor.getSelection().selectRight(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "gotoright", + description: "Go to right", + bindKey: bindKey("Right", "Right|Ctrl-F"), + exec: function(editor, args) { + editor.navigateRight(args.times); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectpagedown", + description: "Select page down", + bindKey: "Shift-PageDown", + exec: function(editor) { + editor.selectPageDown(); + }, + readOnly: !0 + }, + { + name: "pagedown", + description: "Page down", + bindKey: bindKey(null, "Option-PageDown"), + exec: function(editor) { + editor.scrollPageDown(); + }, + readOnly: !0 + }, + { + name: "gotopagedown", + description: "Go to page down", + bindKey: bindKey("PageDown", "PageDown|Ctrl-V"), + exec: function(editor) { + editor.gotoPageDown(); + }, + readOnly: !0 + }, + { + name: "selectpageup", + description: "Select page up", + bindKey: "Shift-PageUp", + exec: function(editor) { + editor.selectPageUp(); + }, + readOnly: !0 + }, + { + name: "pageup", + description: "Page up", + bindKey: bindKey(null, "Option-PageUp"), + exec: function(editor) { + editor.scrollPageUp(); + }, + readOnly: !0 + }, + { + name: "gotopageup", + description: "Go to page up", + bindKey: "PageUp", + exec: function(editor) { + editor.gotoPageUp(); + }, + readOnly: !0 + }, + { + name: "scrollup", + description: "Scroll up", + bindKey: bindKey("Ctrl-Up", null), + exec: function(e) { + e.renderer.scrollBy(0, -2 * e.renderer.layerConfig.lineHeight); + }, + readOnly: !0 + }, + { + name: "scrolldown", + description: "Scroll down", + bindKey: bindKey("Ctrl-Down", null), + exec: function(e) { + e.renderer.scrollBy(0, 2 * e.renderer.layerConfig.lineHeight); + }, + readOnly: !0 + }, + { + name: "selectlinestart", + description: "Select line start", + bindKey: "Shift-Home", + exec: function(editor) { + editor.getSelection().selectLineStart(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectlineend", + description: "Select line end", + bindKey: "Shift-End", + exec: function(editor) { + editor.getSelection().selectLineEnd(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "togglerecording", + description: "Toggle recording", + bindKey: bindKey("Ctrl-Alt-E", "Command-Option-E"), + exec: function(editor) { + editor.commands.toggleRecording(editor); + }, + readOnly: !0 + }, + { + name: "replaymacro", + description: "Replay macro", + bindKey: bindKey("Ctrl-Shift-E", "Command-Shift-E"), + exec: function(editor) { + editor.commands.replay(editor); + }, + readOnly: !0 + }, + { + name: "jumptomatching", + description: "Jump to matching", + bindKey: bindKey("Ctrl-\\|Ctrl-P", "Command-\\"), + exec: function(editor) { + editor.jumpToMatching(); + }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: !0 + }, + { + name: "selecttomatching", + description: "Select to matching", + bindKey: bindKey("Ctrl-Shift-\\|Ctrl-Shift-P", "Command-Shift-\\"), + exec: function(editor) { + editor.jumpToMatching(!0); + }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: !0 + }, + { + name: "expandToMatching", + description: "Expand to matching", + bindKey: bindKey("Ctrl-Shift-M", "Ctrl-Shift-M"), + exec: function(editor) { + editor.jumpToMatching(!0, !0); + }, + multiSelectAction: "forEach", + scrollIntoView: "animate", + readOnly: !0 + }, + { + name: "passKeysToBrowser", + description: "Pass keys to browser", + bindKey: bindKey(null, null), + exec: function() {}, + passEvent: !0, + readOnly: !0 + }, + { + name: "copy", + description: "Copy", + exec: function(editor) {}, + readOnly: !0 + }, + { + name: "cut", + description: "Cut", + exec: function(editor) { + var range = editor.$copyWithEmptySelection && editor.selection.isEmpty() ? editor.selection.getLineRange() : editor.selection.getRange(); + editor._emit("cut", range), range.isEmpty() || editor.session.remove(range), editor.clearSelection(); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" + }, + { + name: "paste", + description: "Paste", + exec: function(editor, args) { + editor.$handlePaste(args); + }, + scrollIntoView: "cursor" + }, + { + name: "removeline", + description: "Remove line", + bindKey: bindKey("Ctrl-D", "Command-D"), + exec: function(editor) { + editor.removeLines(); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEachLine" + }, + { + name: "duplicateSelection", + description: "Duplicate selection", + bindKey: bindKey("Ctrl-Shift-D", "Command-Shift-D"), + exec: function(editor) { + editor.duplicateSelection(); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" + }, + { + name: "sortlines", + description: "Sort lines", + bindKey: bindKey("Ctrl-Alt-S", "Command-Alt-S"), + exec: function(editor) { + editor.sortLines(); + }, + scrollIntoView: "selection", + multiSelectAction: "forEachLine" + }, + { + name: "togglecomment", + description: "Toggle comment", + bindKey: bindKey("Ctrl-/", "Command-/"), + exec: function(editor) { + editor.toggleCommentLines(); + }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" + }, + { + name: "toggleBlockComment", + description: "Toggle block comment", + bindKey: bindKey("Ctrl-Shift-/", "Command-Shift-/"), + exec: function(editor) { + editor.toggleBlockComment(); + }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" + }, + { + name: "modifyNumberUp", + description: "Modify number up", + bindKey: bindKey("Ctrl-Shift-Up", "Alt-Shift-Up"), + exec: function(editor) { + editor.modifyNumber(1); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" + }, + { + name: "modifyNumberDown", + description: "Modify number down", + bindKey: bindKey("Ctrl-Shift-Down", "Alt-Shift-Down"), + exec: function(editor) { + editor.modifyNumber(-1); + }, + scrollIntoView: "cursor", + multiSelectAction: "forEach" + }, + { + name: "replace", + description: "Replace", + bindKey: bindKey("Ctrl-H", "Command-Option-F"), + exec: function(editor) { + config.loadModule("ace/ext/searchbox", function(e) { + e.Search(editor, !0); + }); + } + }, + { + name: "undo", + description: "Undo", + bindKey: bindKey("Ctrl-Z", "Command-Z"), + exec: function(editor) { + editor.undo(); + } + }, + { + name: "redo", + description: "Redo", + bindKey: bindKey("Ctrl-Shift-Z|Ctrl-Y", "Command-Shift-Z|Command-Y"), + exec: function(editor) { + editor.redo(); + } + }, + { + name: "copylinesup", + description: "Copy lines up", + bindKey: bindKey("Alt-Shift-Up", "Command-Option-Up"), + exec: function(editor) { + editor.copyLinesUp(); + }, + scrollIntoView: "cursor" + }, + { + name: "movelinesup", + description: "Move lines up", + bindKey: bindKey("Alt-Up", "Option-Up"), + exec: function(editor) { + editor.moveLinesUp(); + }, + scrollIntoView: "cursor" + }, + { + name: "copylinesdown", + description: "Copy lines down", + bindKey: bindKey("Alt-Shift-Down", "Command-Option-Down"), + exec: function(editor) { + editor.copyLinesDown(); + }, + scrollIntoView: "cursor" + }, + { + name: "movelinesdown", + description: "Move lines down", + bindKey: bindKey("Alt-Down", "Option-Down"), + exec: function(editor) { + editor.moveLinesDown(); + }, + scrollIntoView: "cursor" + }, + { + name: "del", + description: "Delete", + bindKey: bindKey("Delete", "Delete|Ctrl-D|Shift-Delete"), + exec: function(editor) { + editor.remove("right"); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "backspace", + description: "Backspace", + bindKey: bindKey("Shift-Backspace|Backspace", "Ctrl-Backspace|Shift-Backspace|Backspace|Ctrl-H"), + exec: function(editor) { + editor.remove("left"); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "cut_or_delete", + description: "Cut or delete", + bindKey: bindKey("Shift-Delete", null), + exec: function(editor) { + if (!editor.selection.isEmpty()) return !1; + editor.remove("left"); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removetolinestart", + description: "Remove to line start", + bindKey: bindKey("Alt-Backspace", "Command-Backspace"), + exec: function(editor) { + editor.removeToLineStart(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removetolineend", + description: "Remove to line end", + bindKey: bindKey("Alt-Delete", "Ctrl-K|Command-Delete"), + exec: function(editor) { + editor.removeToLineEnd(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removetolinestarthard", + description: "Remove to line start hard", + bindKey: bindKey("Ctrl-Shift-Backspace", null), + exec: function(editor) { + var range = editor.selection.getRange(); + range.start.column = 0, editor.session.remove(range); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removetolineendhard", + description: "Remove to line end hard", + bindKey: bindKey("Ctrl-Shift-Delete", null), + exec: function(editor) { + var range = editor.selection.getRange(); + range.end.column = Number.MAX_VALUE, editor.session.remove(range); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removewordleft", + description: "Remove word left", + bindKey: bindKey("Ctrl-Backspace", "Alt-Backspace|Ctrl-Alt-Backspace"), + exec: function(editor) { + editor.removeWordLeft(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "removewordright", + description: "Remove word right", + bindKey: bindKey("Ctrl-Delete", "Alt-Delete"), + exec: function(editor) { + editor.removeWordRight(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "outdent", + description: "Outdent", + bindKey: bindKey("Shift-Tab", "Shift-Tab"), + exec: function(editor) { + editor.blockOutdent(); + }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" + }, + { + name: "indent", + description: "Indent", + bindKey: bindKey("Tab", "Tab"), + exec: function(editor) { + editor.indent(); + }, + multiSelectAction: "forEach", + scrollIntoView: "selectionPart" + }, + { + name: "blockoutdent", + description: "Block outdent", + bindKey: bindKey("Ctrl-[", "Ctrl-["), + exec: function(editor) { + editor.blockOutdent(); + }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" + }, + { + name: "blockindent", + description: "Block indent", + bindKey: bindKey("Ctrl-]", "Ctrl-]"), + exec: function(editor) { + editor.blockIndent(); + }, + multiSelectAction: "forEachLine", + scrollIntoView: "selectionPart" + }, + { + name: "insertstring", + description: "Insert string", + exec: function(editor, str) { + editor.insert(str); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "inserttext", + description: "Insert text", + exec: function(editor, args) { + editor.insert(lang.stringRepeat(args.text || "", args.times || 1)); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "splitline", + description: "Split line", + bindKey: bindKey(null, "Ctrl-O"), + exec: function(editor) { + editor.splitLine(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "transposeletters", + description: "Transpose letters", + bindKey: bindKey("Alt-Shift-X", "Ctrl-T"), + exec: function(editor) { + editor.transposeLetters(); + }, + multiSelectAction: function(editor) { + editor.transposeSelections(1); + }, + scrollIntoView: "cursor" + }, + { + name: "touppercase", + description: "To uppercase", + bindKey: bindKey("Ctrl-U", "Ctrl-U"), + exec: function(editor) { + editor.toUpperCase(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "tolowercase", + description: "To lowercase", + bindKey: bindKey("Ctrl-Shift-U", "Ctrl-Shift-U"), + exec: function(editor) { + editor.toLowerCase(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "autoindent", + description: "Auto Indent", + bindKey: bindKey(null, null), + exec: function(editor) { + editor.autoIndent(); + }, + multiSelectAction: "forEachLine", + scrollIntoView: "animate" + }, + { + name: "expandtoline", + description: "Expand to line", + bindKey: bindKey("Ctrl-Shift-L", "Command-Shift-L"), + exec: function(editor) { + var range = editor.selection.getRange(); + range.start.column = range.end.column = 0, range.end.row++, editor.selection.setRange(range, !1); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "joinlines", + description: "Join lines", + bindKey: bindKey(null, null), + exec: function(editor) { + for(var isBackwards = editor.selection.isBackwards(), selectionStart = isBackwards ? editor.selection.getSelectionLead() : editor.selection.getSelectionAnchor(), selectionEnd = isBackwards ? editor.selection.getSelectionAnchor() : editor.selection.getSelectionLead(), firstLineEndCol = editor.session.doc.getLine(selectionStart.row).length, selectedCount = editor.session.doc.getTextRange(editor.selection.getRange()).replace(/\n\s*/, " ").length, insertLine = editor.session.doc.getLine(selectionStart.row), i = selectionStart.row + 1; i <= selectionEnd.row + 1; i++){ + var curLine = lang.stringTrimLeft(lang.stringTrimRight(editor.session.doc.getLine(i))); + 0 !== curLine.length && (curLine = " " + curLine), insertLine += curLine; + } + selectionEnd.row + 1 < editor.session.doc.getLength() - 1 && (insertLine += editor.session.doc.getNewLineCharacter()), editor.clearSelection(), editor.session.doc.replace(new Range(selectionStart.row, 0, selectionEnd.row + 2, 0), insertLine), selectedCount > 0 ? (editor.selection.moveCursorTo(selectionStart.row, selectionStart.column), editor.selection.selectTo(selectionStart.row, selectionStart.column + selectedCount)) : (firstLineEndCol = editor.session.doc.getLine(selectionStart.row).length > firstLineEndCol ? firstLineEndCol + 1 : firstLineEndCol, editor.selection.moveCursorTo(selectionStart.row, firstLineEndCol)); + }, + multiSelectAction: "forEach", + readOnly: !0 + }, + { + name: "invertSelection", + description: "Invert selection", + bindKey: bindKey(null, null), + exec: function(editor) { + var endRow = editor.session.doc.getLength() - 1, endCol = editor.session.doc.getLine(endRow).length, ranges = editor.selection.rangeList.ranges, newRanges = []; + ranges.length < 1 && (ranges = [ + editor.selection.getRange() + ]); + for(var i = 0; i < ranges.length; i++)i != ranges.length - 1 || ranges[i].end.row === endRow && ranges[i].end.column === endCol || newRanges.push(new Range(ranges[i].end.row, ranges[i].end.column, endRow, endCol)), 0 === i ? 0 === ranges[i].start.row && 0 === ranges[i].start.column || newRanges.push(new Range(0, 0, ranges[i].start.row, ranges[i].start.column)) : newRanges.push(new Range(ranges[i - 1].end.row, ranges[i - 1].end.column, ranges[i].start.row, ranges[i].start.column)); + editor.exitMultiSelectMode(), editor.clearSelection(); + for(var i = 0; i < newRanges.length; i++)editor.selection.addRange(newRanges[i], !1); + }, + readOnly: !0, + scrollIntoView: "none" + }, + { + name: "addLineAfter", + description: "Add new line after the current line", + exec: function(editor) { + editor.selection.clearSelection(), editor.navigateLineEnd(), editor.insert("\n"); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "addLineBefore", + description: "Add new line before the current line", + exec: function(editor) { + editor.selection.clearSelection(); + var cursor = editor.getCursorPosition(); + editor.selection.moveTo(cursor.row - 1, Number.MAX_VALUE), editor.insert("\n"), 0 === cursor.row && editor.navigateUp(); + }, + multiSelectAction: "forEach", + scrollIntoView: "cursor" + }, + { + name: "openCommandPallete", + description: "Open command pallete", + bindKey: bindKey("F1", "F1"), + exec: function(editor) { + editor.prompt({ + $type: "commands" + }); + }, + readOnly: !0 + }, + { + name: "modeSelect", + description: "Change language mode...", + bindKey: bindKey(null, null), + exec: function(editor) { + editor.prompt({ + $type: "modes" + }); + }, + readOnly: !0 + } + ]; + for(var i4 = 1; i4 < 9; i4++)exports.commands.push({ + name: "foldToLevel" + i4, + description: "Fold To Level " + i4, + level: i4, + exec: function(editor) { + editor.session.foldToLevel(this.level); + }, + scrollIntoView: "center", + readOnly: !0 + }); + }), ace.define("ace/editor", [ + "require", + "exports", + "module", + "ace/lib/fixoldbrowsers", + "ace/lib/oop", + "ace/lib/dom", + "ace/lib/lang", + "ace/lib/useragent", + "ace/keyboard/textinput", + "ace/mouse/mouse_handler", + "ace/mouse/fold_handler", + "ace/keyboard/keybinding", + "ace/edit_session", + "ace/search", + "ace/range", + "ace/lib/event_emitter", + "ace/commands/command_manager", + "ace/commands/default_commands", + "ace/config", + "ace/token_iterator", + "ace/clipboard" + ], function(require, exports, module7) { + "use strict"; + require("./lib/fixoldbrowsers"); + var oop = require("./lib/oop"), dom = require("./lib/dom"), lang = require("./lib/lang"), useragent = require("./lib/useragent"), TextInput = require("./keyboard/textinput").TextInput, MouseHandler = require("./mouse/mouse_handler").MouseHandler, FoldHandler = require("./mouse/fold_handler").FoldHandler, KeyBinding = require("./keyboard/keybinding").KeyBinding, EditSession = require("./edit_session").EditSession, Search = require("./search").Search, Range = require("./range").Range, EventEmitter = require("./lib/event_emitter").EventEmitter, CommandManager = require("./commands/command_manager").CommandManager, defaultCommands = require("./commands/default_commands").commands, config1 = require("./config"), TokenIterator = require("./token_iterator").TokenIterator, clipboard = require("./clipboard"), Editor = function(renderer, session, options) { + this.$toDestroy = []; + var container = renderer.getContainerElement(); + this.container = container, this.renderer = renderer, this.id = "editor" + ++Editor.$uid, this.commands = new CommandManager(useragent.isMac ? "mac" : "win", defaultCommands), "object" == typeof document && (this.textInput = new TextInput(renderer.getTextAreaContainer(), this), this.renderer.textarea = this.textInput.getElement(), this.$mouseHandler = new MouseHandler(this), new FoldHandler(this)), this.keyBinding = new KeyBinding(this), this.$search = new Search().set({ + wrap: !0 + }), this.$historyTracker = this.$historyTracker.bind(this), this.commands.on("exec", this.$historyTracker), this.$initOperationListeners(), this._$emitInputEvent = lang.delayedCall((function() { + this._signal("input", {}), this.session && this.session.bgTokenizer && this.session.bgTokenizer.scheduleStart(); + }).bind(this)), this.on("change", function(_, _self) { + _self._$emitInputEvent.schedule(31); + }), this.setSession(session || options && options.session || new EditSession("")), config1.resetOptions(this), options && this.setOptions(options), config1._signal("editor", this); + }; + Editor.$uid = 0, (function() { + oop.implement(this, EventEmitter), this.$initOperationListeners = function() { + this.commands.on("exec", this.startOperation.bind(this), !0), this.commands.on("afterExec", this.endOperation.bind(this), !0), this.$opResetTimer = lang.delayedCall(this.endOperation.bind(this, !0)), this.on("change", (function() { + this.curOp || (this.startOperation(), this.curOp.selectionBefore = this.$lastSel), this.curOp.docChanged = !0; + }).bind(this), !0), this.on("changeSelection", (function() { + this.curOp || (this.startOperation(), this.curOp.selectionBefore = this.$lastSel), this.curOp.selectionChanged = !0; + }).bind(this), !0); + }, this.curOp = null, this.prevOp = {}, this.startOperation = function(commandEvent) { + if (this.curOp) { + if (!commandEvent || this.curOp.command) return; + this.prevOp = this.curOp; + } + commandEvent || (this.previousCommand = null, commandEvent = {}), this.$opResetTimer.schedule(), this.curOp = this.session.curOp = { + command: commandEvent.command || {}, + args: commandEvent.args, + scrollTop: this.renderer.scrollTop + }, this.curOp.selectionBefore = this.selection.toJSON(); + }, this.endOperation = function(e) { + if (this.curOp && this.session) { + if (e && !1 === e.returnValue || !this.session) return this.curOp = null; + if ((!0 != e || !this.curOp.command || "mouse" != this.curOp.command.name) && (this._signal("beforeEndOperation"), this.curOp)) { + var command = this.curOp.command, scrollIntoView = command && command.scrollIntoView; + if (scrollIntoView) { + switch(scrollIntoView){ + case "center-animate": + scrollIntoView = "animate"; + case "center": + this.renderer.scrollCursorIntoView(null, 0.5); + break; + case "animate": + case "cursor": + this.renderer.scrollCursorIntoView(); + break; + case "selectionPart": + var range = this.selection.getRange(), config = this.renderer.layerConfig; + (range.start.row >= config.lastRow || range.end.row <= config.firstRow) && this.renderer.scrollSelectionIntoView(this.selection.anchor, this.selection.lead); + break; + default: + break; + } + "animate" == scrollIntoView && this.renderer.animateScrolling(this.curOp.scrollTop); + } + var sel = this.selection.toJSON(); + this.curOp.selectionAfter = sel, this.$lastSel = this.selection.toJSON(), this.session.getUndoManager().addSelection(sel), this.prevOp = this.curOp, this.curOp = null; + } + } + }, this.$mergeableCommands = [ + "backspace", + "del", + "insertstring" + ], this.$historyTracker = function(e) { + if (this.$mergeUndoDeltas) { + var prev = this.prevOp, mergeableCommands = this.$mergeableCommands, shouldMerge = prev.command && e.command.name == prev.command.name; + if ("insertstring" == e.command.name) { + var text = e.args; + void 0 === this.mergeNextCommand && (this.mergeNextCommand = !0), shouldMerge = shouldMerge && this.mergeNextCommand && (!/\s/.test(text) || /\s/.test(prev.args)), this.mergeNextCommand = !0; + } else shouldMerge = shouldMerge && -1 !== mergeableCommands.indexOf(e.command.name); + "always" != this.$mergeUndoDeltas && Date.now() - this.sequenceStartTime > 2000 && (shouldMerge = !1), shouldMerge ? this.session.mergeUndoDeltas = !0 : -1 !== mergeableCommands.indexOf(e.command.name) && (this.sequenceStartTime = Date.now()); + } + }, this.setKeyboardHandler = function(keyboardHandler, cb) { + if (keyboardHandler && "string" == typeof keyboardHandler && "ace" != keyboardHandler) { + this.$keybindingId = keyboardHandler; + var _self = this; + config1.loadModule([ + "keybinding", + keyboardHandler + ], function(module) { + _self.$keybindingId == keyboardHandler && _self.keyBinding.setKeyboardHandler(module && module.handler), cb && cb(); + }); + } else this.$keybindingId = null, this.keyBinding.setKeyboardHandler(keyboardHandler), cb && cb(); + }, this.getKeyboardHandler = function() { + return this.keyBinding.getKeyboardHandler(); + }, this.setSession = function(session) { + if (this.session != session) { + this.curOp && this.endOperation(), this.curOp = {}; + var oldSession = this.session; + if (oldSession) { + this.session.off("change", this.$onDocumentChange), this.session.off("changeMode", this.$onChangeMode), this.session.off("tokenizerUpdate", this.$onTokenizerUpdate), this.session.off("changeTabSize", this.$onChangeTabSize), this.session.off("changeWrapLimit", this.$onChangeWrapLimit), this.session.off("changeWrapMode", this.$onChangeWrapMode), this.session.off("changeFold", this.$onChangeFold), this.session.off("changeFrontMarker", this.$onChangeFrontMarker), this.session.off("changeBackMarker", this.$onChangeBackMarker), this.session.off("changeBreakpoint", this.$onChangeBreakpoint), this.session.off("changeAnnotation", this.$onChangeAnnotation), this.session.off("changeOverwrite", this.$onCursorChange), this.session.off("changeScrollTop", this.$onScrollTopChange), this.session.off("changeScrollLeft", this.$onScrollLeftChange); + var selection = this.session.getSelection(); + selection.off("changeCursor", this.$onCursorChange), selection.off("changeSelection", this.$onSelectionChange); + } + this.session = session, session ? (this.$onDocumentChange = this.onDocumentChange.bind(this), session.on("change", this.$onDocumentChange), this.renderer.setSession(session), this.$onChangeMode = this.onChangeMode.bind(this), session.on("changeMode", this.$onChangeMode), this.$onTokenizerUpdate = this.onTokenizerUpdate.bind(this), session.on("tokenizerUpdate", this.$onTokenizerUpdate), this.$onChangeTabSize = this.renderer.onChangeTabSize.bind(this.renderer), session.on("changeTabSize", this.$onChangeTabSize), this.$onChangeWrapLimit = this.onChangeWrapLimit.bind(this), session.on("changeWrapLimit", this.$onChangeWrapLimit), this.$onChangeWrapMode = this.onChangeWrapMode.bind(this), session.on("changeWrapMode", this.$onChangeWrapMode), this.$onChangeFold = this.onChangeFold.bind(this), session.on("changeFold", this.$onChangeFold), this.$onChangeFrontMarker = this.onChangeFrontMarker.bind(this), this.session.on("changeFrontMarker", this.$onChangeFrontMarker), this.$onChangeBackMarker = this.onChangeBackMarker.bind(this), this.session.on("changeBackMarker", this.$onChangeBackMarker), this.$onChangeBreakpoint = this.onChangeBreakpoint.bind(this), this.session.on("changeBreakpoint", this.$onChangeBreakpoint), this.$onChangeAnnotation = this.onChangeAnnotation.bind(this), this.session.on("changeAnnotation", this.$onChangeAnnotation), this.$onCursorChange = this.onCursorChange.bind(this), this.session.on("changeOverwrite", this.$onCursorChange), this.$onScrollTopChange = this.onScrollTopChange.bind(this), this.session.on("changeScrollTop", this.$onScrollTopChange), this.$onScrollLeftChange = this.onScrollLeftChange.bind(this), this.session.on("changeScrollLeft", this.$onScrollLeftChange), this.selection = session.getSelection(), this.selection.on("changeCursor", this.$onCursorChange), this.$onSelectionChange = this.onSelectionChange.bind(this), this.selection.on("changeSelection", this.$onSelectionChange), this.onChangeMode(), this.onCursorChange(), this.onScrollTopChange(), this.onScrollLeftChange(), this.onSelectionChange(), this.onChangeFrontMarker(), this.onChangeBackMarker(), this.onChangeBreakpoint(), this.onChangeAnnotation(), this.session.getUseWrapMode() && this.renderer.adjustWrapLimit(), this.renderer.updateFull()) : (this.selection = null, this.renderer.setSession(session)), this._signal("changeSession", { + session: session, + oldSession: oldSession + }), this.curOp = null, oldSession && oldSession._signal("changeEditor", { + oldEditor: this + }), session && session._signal("changeEditor", { + editor: this + }), session && session.bgTokenizer && session.bgTokenizer.scheduleStart(); + } + }, this.getSession = function() { + return this.session; + }, this.setValue = function(val, cursorPos) { + return this.session.doc.setValue(val), cursorPos ? 1 == cursorPos ? this.navigateFileEnd() : -1 == cursorPos && this.navigateFileStart() : this.selectAll(), val; + }, this.getValue = function() { + return this.session.getValue(); + }, this.getSelection = function() { + return this.selection; + }, this.resize = function(force) { + this.renderer.onResize(force); + }, this.setTheme = function(theme, cb) { + this.renderer.setTheme(theme, cb); + }, this.getTheme = function() { + return this.renderer.getTheme(); + }, this.setStyle = function(style) { + this.renderer.setStyle(style); + }, this.unsetStyle = function(style) { + this.renderer.unsetStyle(style); + }, this.getFontSize = function() { + return this.getOption("fontSize") || dom.computedStyle(this.container).fontSize; + }, this.setFontSize = function(size) { + this.setOption("fontSize", size); + }, this.$highlightBrackets = function() { + if (!this.$highlightPending) { + var self = this; + this.$highlightPending = !0, setTimeout(function() { + self.$highlightPending = !1; + var session = self.session; + if (session && session.bgTokenizer) { + session.$bracketHighlight && (session.$bracketHighlight.markerIds.forEach(function(id) { + session.removeMarker(id); + }), session.$bracketHighlight = null); + var ranges = session.getMatchingBracketRanges(self.getCursorPosition()); + if (!ranges && session.$mode.getMatching && (ranges = session.$mode.getMatching(self.session)), ranges) { + var markerType = "ace_bracket"; + Array.isArray(ranges) ? 1 == ranges.length && (markerType = "ace_error_bracket") : ranges = [ + ranges + ], 2 == ranges.length && (0 == Range.comparePoints(ranges[0].end, ranges[1].start) ? ranges = [ + Range.fromPoints(ranges[0].start, ranges[1].end) + ] : 0 == Range.comparePoints(ranges[0].start, ranges[1].end) && (ranges = [ + Range.fromPoints(ranges[1].start, ranges[0].end) + ])), session.$bracketHighlight = { + ranges: ranges, + markerIds: ranges.map(function(range) { + return session.addMarker(range, markerType, "text"); + }) + }; + } + } + }, 50); + } + }, this.$highlightTags = function() { + if (!this.$highlightTagPending) { + var self = this; + this.$highlightTagPending = !0, setTimeout(function() { + self.$highlightTagPending = !1; + var session = self.session; + if (session && session.bgTokenizer) { + var pos = self.getCursorPosition(), iterator = new TokenIterator(self.session, pos.row, pos.column), token = iterator.getCurrentToken(); + if (!token || !/\b(?:tag-open|tag-name)/.test(token.type)) { + session.removeMarker(session.$tagHighlight), session.$tagHighlight = null; + return; + } + if (-1 !== token.type.indexOf("tag-open") && !(token = iterator.stepForward())) return; + var tag = token.value, currentTag = token.value, depth = 0, prevToken = iterator.stepBackward(); + if ('<' === prevToken.value) do prevToken = token, (token = iterator.stepForward()) && (-1 !== token.type.indexOf('tag-name') ? tag === (currentTag = token.value) && ('<' === prevToken.value ? depth++ : '' === token.value && depth--); + while (token && depth >= 0) + else { + do if (token = prevToken, prevToken = iterator.stepBackward(), token) { + if (-1 !== token.type.indexOf('tag-name')) tag === token.value && ('<' === prevToken.value ? depth++ : '' === token.value) { + for(var stepCount = 0, tmpToken = prevToken; tmpToken;){ + if (-1 !== tmpToken.type.indexOf('tag-name') && tmpToken.value === tag) { + depth--; + break; + } + if ('<' === tmpToken.value) break; + tmpToken = iterator.stepBackward(), stepCount++; + } + for(var i = 0; i < stepCount; i++)iterator.stepForward(); + } + } + while (prevToken && depth <= 0) + iterator.stepForward(); + } + if (!token) { + session.removeMarker(session.$tagHighlight), session.$tagHighlight = null; + return; + } + var row = iterator.getCurrentTokenRow(), column = iterator.getCurrentTokenColumn(), range = new Range(row, column, row, column + token.value.length), sbm = session.$backMarkers[session.$tagHighlight]; + session.$tagHighlight && void 0 != sbm && 0 !== range.compareRange(sbm.range) && (session.removeMarker(session.$tagHighlight), session.$tagHighlight = null), session.$tagHighlight || (session.$tagHighlight = session.addMarker(range, "ace_bracket", "text")); + } + }, 50); + } + }, this.focus = function() { + var _self = this; + setTimeout(function() { + _self.isFocused() || _self.textInput.focus(); + }), this.textInput.focus(); + }, this.isFocused = function() { + return this.textInput.isFocused(); + }, this.blur = function() { + this.textInput.blur(); + }, this.onFocus = function(e) { + this.$isFocused || (this.$isFocused = !0, this.renderer.showCursor(), this.renderer.visualizeFocus(), this._emit("focus", e)); + }, this.onBlur = function(e) { + this.$isFocused && (this.$isFocused = !1, this.renderer.hideCursor(), this.renderer.visualizeBlur(), this._emit("blur", e)); + }, this.$cursorChange = function() { + this.renderer.updateCursor(), this.$highlightBrackets(), this.$highlightTags(), this.$updateHighlightActiveLine(); + }, this.onDocumentChange = function(delta) { + var wrap = this.session.$useWrapMode, lastRow = delta.start.row == delta.end.row ? delta.end.row : 1 / 0; + this.renderer.updateLines(delta.start.row, lastRow, wrap), this._signal("change", delta), this.$cursorChange(); + }, this.onTokenizerUpdate = function(e) { + var rows = e.data; + this.renderer.updateLines(rows.first, rows.last); + }, this.onScrollTopChange = function() { + this.renderer.scrollToY(this.session.getScrollTop()); + }, this.onScrollLeftChange = function() { + this.renderer.scrollToX(this.session.getScrollLeft()); + }, this.onCursorChange = function() { + this.$cursorChange(), this._signal("changeSelection"); + }, this.$updateHighlightActiveLine = function() { + var highlight, session = this.getSession(); + if (this.$highlightActiveLine && ("line" == this.$selectionStyle && this.selection.isMultiLine() || (highlight = this.getCursorPosition()), this.renderer.theme && this.renderer.theme.$selectionColorConflict && !this.selection.isEmpty() && (highlight = !1), this.renderer.$maxLines && 1 === this.session.getLength() && !(this.renderer.$minLines > 1) && (highlight = !1)), session.$highlightLineMarker && !highlight) session.removeMarker(session.$highlightLineMarker.id), session.$highlightLineMarker = null; + else if (!session.$highlightLineMarker && highlight) { + var range = new Range(highlight.row, highlight.column, highlight.row, 1 / 0); + range.id = session.addMarker(range, "ace_active-line", "screenLine"), session.$highlightLineMarker = range; + } else highlight && (session.$highlightLineMarker.start.row = highlight.row, session.$highlightLineMarker.end.row = highlight.row, session.$highlightLineMarker.start.column = highlight.column, session._signal("changeBackMarker")); + }, this.onSelectionChange = function(e) { + var session = this.session; + if (session.$selectionMarker && session.removeMarker(session.$selectionMarker), session.$selectionMarker = null, this.selection.isEmpty()) this.$updateHighlightActiveLine(); + else { + var range = this.selection.getRange(), style = this.getSelectionStyle(); + session.$selectionMarker = session.addMarker(range, "ace_selection", style); + } + var re = this.$highlightSelectedWord && this.$getSelectionHighLightRegexp(); + this.session.highlight(re), this._signal("changeSelection"); + }, this.$getSelectionHighLightRegexp = function() { + var session = this.session, selection = this.getSelectionRange(); + if (!(selection.isEmpty() || selection.isMultiLine())) { + var startColumn = selection.start.column, endColumn = selection.end.column, line = session.getLine(selection.start.row), needle = line.substring(startColumn, endColumn); + if (!(needle.length > 5000) && /[\w\d]/.test(needle)) { + var re = this.$search.$assembleRegExp({ + wholeWord: !0, + caseSensitive: !0, + needle: needle + }), wordWithBoundary = line.substring(startColumn - 1, endColumn + 1); + if (re.test(wordWithBoundary)) return re; + } + } + }, this.onChangeFrontMarker = function() { + this.renderer.updateFrontMarkers(); + }, this.onChangeBackMarker = function() { + this.renderer.updateBackMarkers(); + }, this.onChangeBreakpoint = function() { + this.renderer.updateBreakpoints(); + }, this.onChangeAnnotation = function() { + this.renderer.setAnnotations(this.session.getAnnotations()); + }, this.onChangeMode = function(e) { + this.renderer.updateText(), this._emit("changeMode", e); + }, this.onChangeWrapLimit = function() { + this.renderer.updateFull(); + }, this.onChangeWrapMode = function() { + this.renderer.onResize(!0); + }, this.onChangeFold = function() { + this.$updateHighlightActiveLine(), this.renderer.updateFull(); + }, this.getSelectedText = function() { + return this.session.getTextRange(this.getSelectionRange()); + }, this.getCopyText = function() { + var text = this.getSelectedText(), nl = this.session.doc.getNewLineCharacter(), copyLine = !1; + if (!text && this.$copyWithEmptySelection) { + copyLine = !0; + for(var ranges = this.selection.getAllRanges(), i = 0; i < ranges.length; i++){ + var range = ranges[i]; + i && ranges[i - 1].start.row == range.start.row || (text += this.session.getLine(range.start.row) + nl); + } + } + var e = { + text: text + }; + return this._signal("copy", e), clipboard.lineMode = !!copyLine && e.text, e.text; + }, this.onCopy = function() { + this.commands.exec("copy", this); + }, this.onCut = function() { + this.commands.exec("cut", this); + }, this.onPaste = function(text, event) { + this.commands.exec("paste", this, { + text: text, + event: event + }); + }, this.$handlePaste = function(e) { + "string" == typeof e && (e = { + text: e + }), this._signal("paste", e); + var text = e.text, lineMode = text === clipboard.lineMode, session = this.session; + if (!this.inMultiSelectMode || this.inVirtualSelectionMode) lineMode ? session.insert({ + row: this.selection.lead.row, + column: 0 + }, text) : this.insert(text); + else if (lineMode) this.selection.rangeList.ranges.forEach(function(range) { + session.insert({ + row: range.start.row, + column: 0 + }, text); + }); + else { + var lines = text.split(/\r\n|\r|\n/), ranges = this.selection.rangeList.ranges, isFullLine = 2 == lines.length && (!lines[0] || !lines[1]); + if (lines.length != ranges.length || isFullLine) return this.commands.exec("insertstring", this, text); + for(var i = ranges.length; i--;){ + var range3 = ranges[i]; + range3.isEmpty() || session.remove(range3), session.insert(range3.start, lines[i]); + } + } + }, this.execCommand = function(command, args) { + return this.commands.exec(command, this, args); + }, this.insert = function(text, pasted) { + var session = this.session, mode = session.getMode(), cursor = this.getCursorPosition(); + if (this.getBehavioursEnabled() && !pasted) { + var transform = mode.transformAction(session.getState(cursor.row), 'insertion', this, session, text); + transform && (text === transform.text || this.inVirtualSelectionMode || (this.session.mergeUndoDeltas = !1, this.mergeNextCommand = !1), text = transform.text); + } + if ("\t" == text && (text = this.session.getTabString()), this.selection.isEmpty()) { + if (this.session.getOverwrite() && -1 == text.indexOf("\n")) { + var range = new Range.fromPoints(cursor, cursor); + range.end.column += text.length, this.session.remove(range); + } + } else { + var range = this.getSelectionRange(); + cursor = this.session.remove(range), this.clearSelection(); + } + if ("\n" == text || "\r\n" == text) { + var line = session.getLine(cursor.row); + if (cursor.column > line.search(/\S|$/)) { + var d = line.substr(cursor.column).search(/\S|$/); + session.doc.removeInLine(cursor.row, cursor.column, cursor.column + d); + } + } + this.clearSelection(); + var start = cursor.column, lineState = session.getState(cursor.row), line = session.getLine(cursor.row), shouldOutdent = mode.checkOutdent(lineState, line, text); + if (session.insert(cursor, text), transform && transform.selection && (2 == transform.selection.length ? this.selection.setSelectionRange(new Range(cursor.row, start + transform.selection[0], cursor.row, start + transform.selection[1])) : this.selection.setSelectionRange(new Range(cursor.row + transform.selection[0], transform.selection[1], cursor.row + transform.selection[2], transform.selection[3]))), this.$enableAutoIndent) { + if (session.getDocument().isNewLine(text)) { + var lineIndent = mode.getNextLineIndent(lineState, line.slice(0, cursor.column), session.getTabString()); + session.insert({ + row: cursor.row + 1, + column: 0 + }, lineIndent); + } + shouldOutdent && mode.autoOutdent(lineState, session, cursor.row); + } + }, this.autoIndent = function() { + var startRow, endRow, line, currIndent, range, session = this.session, mode = session.getMode(); + if (this.selection.isEmpty()) startRow = 0, endRow = session.doc.getLength() - 1; + else { + var selectedRange = this.getSelectionRange(); + startRow = selectedRange.start.row, endRow = selectedRange.end.row; + } + for(var prevLineState = "", prevLine = "", lineIndent = "", tab = session.getTabString(), row = startRow; row <= endRow; row++)row > 0 && (prevLineState = session.getState(row - 1), prevLine = session.getLine(row - 1), lineIndent = mode.getNextLineIndent(prevLineState, prevLine, tab)), line = session.getLine(row), lineIndent !== (currIndent = mode.$getIndent(line)) && (currIndent.length > 0 && (range = new Range(row, 0, row, currIndent.length), session.remove(range)), lineIndent.length > 0 && session.insert({ + row: row, + column: 0 + }, lineIndent)), mode.autoOutdent(prevLineState, session, row); + }, this.onTextInput = function(text, composition) { + if (!composition) return this.keyBinding.onTextInput(text); + this.startOperation({ + command: { + name: "insertstring" + } + }); + var applyComposition = this.applyComposition.bind(this, text, composition); + this.selection.rangeCount ? this.forEachSelection(applyComposition) : applyComposition(), this.endOperation(); + }, this.applyComposition = function(text, composition) { + if (composition.extendLeft || composition.extendRight) { + var r = this.selection.getRange(); + r.start.column -= composition.extendLeft, r.end.column += composition.extendRight, r.start.column < 0 && (r.start.row--, r.start.column += this.session.getLine(r.start.row).length + 1), this.selection.setRange(r), text || r.isEmpty() || this.remove(); + } + if ((text || !this.selection.isEmpty()) && this.insert(text, !0), composition.restoreStart || composition.restoreEnd) { + var r = this.selection.getRange(); + r.start.column -= composition.restoreStart, r.end.column -= composition.restoreEnd, this.selection.setRange(r); + } + }, this.onCommandKey = function(e, hashId, keyCode) { + return this.keyBinding.onCommandKey(e, hashId, keyCode); + }, this.setOverwrite = function(overwrite) { + this.session.setOverwrite(overwrite); + }, this.getOverwrite = function() { + return this.session.getOverwrite(); + }, this.toggleOverwrite = function() { + this.session.toggleOverwrite(); + }, this.setScrollSpeed = function(speed) { + this.setOption("scrollSpeed", speed); + }, this.getScrollSpeed = function() { + return this.getOption("scrollSpeed"); + }, this.setDragDelay = function(dragDelay) { + this.setOption("dragDelay", dragDelay); + }, this.getDragDelay = function() { + return this.getOption("dragDelay"); + }, this.setSelectionStyle = function(val) { + this.setOption("selectionStyle", val); + }, this.getSelectionStyle = function() { + return this.getOption("selectionStyle"); + }, this.setHighlightActiveLine = function(shouldHighlight) { + this.setOption("highlightActiveLine", shouldHighlight); + }, this.getHighlightActiveLine = function() { + return this.getOption("highlightActiveLine"); + }, this.setHighlightGutterLine = function(shouldHighlight) { + this.setOption("highlightGutterLine", shouldHighlight); + }, this.getHighlightGutterLine = function() { + return this.getOption("highlightGutterLine"); + }, this.setHighlightSelectedWord = function(shouldHighlight) { + this.setOption("highlightSelectedWord", shouldHighlight); + }, this.getHighlightSelectedWord = function() { + return this.$highlightSelectedWord; + }, this.setAnimatedScroll = function(shouldAnimate) { + this.renderer.setAnimatedScroll(shouldAnimate); + }, this.getAnimatedScroll = function() { + return this.renderer.getAnimatedScroll(); + }, this.setShowInvisibles = function(showInvisibles) { + this.renderer.setShowInvisibles(showInvisibles); + }, this.getShowInvisibles = function() { + return this.renderer.getShowInvisibles(); + }, this.setDisplayIndentGuides = function(display) { + this.renderer.setDisplayIndentGuides(display); + }, this.getDisplayIndentGuides = function() { + return this.renderer.getDisplayIndentGuides(); + }, this.setShowPrintMargin = function(showPrintMargin) { + this.renderer.setShowPrintMargin(showPrintMargin); + }, this.getShowPrintMargin = function() { + return this.renderer.getShowPrintMargin(); + }, this.setPrintMarginColumn = function(showPrintMargin) { + this.renderer.setPrintMarginColumn(showPrintMargin); + }, this.getPrintMarginColumn = function() { + return this.renderer.getPrintMarginColumn(); + }, this.setReadOnly = function(readOnly) { + this.setOption("readOnly", readOnly); + }, this.getReadOnly = function() { + return this.getOption("readOnly"); + }, this.setBehavioursEnabled = function(enabled) { + this.setOption("behavioursEnabled", enabled); + }, this.getBehavioursEnabled = function() { + return this.getOption("behavioursEnabled"); + }, this.setWrapBehavioursEnabled = function(enabled) { + this.setOption("wrapBehavioursEnabled", enabled); + }, this.getWrapBehavioursEnabled = function() { + return this.getOption("wrapBehavioursEnabled"); + }, this.setShowFoldWidgets = function(show) { + this.setOption("showFoldWidgets", show); + }, this.getShowFoldWidgets = function() { + return this.getOption("showFoldWidgets"); + }, this.setFadeFoldWidgets = function(fade) { + this.setOption("fadeFoldWidgets", fade); + }, this.getFadeFoldWidgets = function() { + return this.getOption("fadeFoldWidgets"); + }, this.remove = function(dir) { + this.selection.isEmpty() && ("left" == dir ? this.selection.selectLeft() : this.selection.selectRight()); + var range = this.getSelectionRange(); + if (this.getBehavioursEnabled()) { + var session = this.session, state = session.getState(range.start.row), new_range = session.getMode().transformAction(state, 'deletion', this, session, range); + if (0 === range.end.column) { + var text = session.getTextRange(range); + if ("\n" == text[text.length - 1]) { + var line = session.getLine(range.end.row); + /^\s+$/.test(line) && (range.end.column = line.length); + } + } + new_range && (range = new_range); + } + this.session.remove(range), this.clearSelection(); + }, this.removeWordRight = function() { + this.selection.isEmpty() && this.selection.selectWordRight(), this.session.remove(this.getSelectionRange()), this.clearSelection(); + }, this.removeWordLeft = function() { + this.selection.isEmpty() && this.selection.selectWordLeft(), this.session.remove(this.getSelectionRange()), this.clearSelection(); + }, this.removeToLineStart = function() { + this.selection.isEmpty() && this.selection.selectLineStart(), this.selection.isEmpty() && this.selection.selectLeft(), this.session.remove(this.getSelectionRange()), this.clearSelection(); + }, this.removeToLineEnd = function() { + this.selection.isEmpty() && this.selection.selectLineEnd(); + var range = this.getSelectionRange(); + range.start.column == range.end.column && range.start.row == range.end.row && (range.end.column = 0, range.end.row++), this.session.remove(range), this.clearSelection(); + }, this.splitLine = function() { + this.selection.isEmpty() || (this.session.remove(this.getSelectionRange()), this.clearSelection()); + var cursor = this.getCursorPosition(); + this.insert("\n"), this.moveCursorToPosition(cursor); + }, this.transposeLetters = function() { + if (this.selection.isEmpty()) { + var swap, range, cursor = this.getCursorPosition(), column = cursor.column; + if (0 !== column) { + var line = this.session.getLine(cursor.row); + column < line.length ? (swap = line.charAt(column) + line.charAt(column - 1), range = new Range(cursor.row, column - 1, cursor.row, column + 1)) : (swap = line.charAt(column - 1) + line.charAt(column - 2), range = new Range(cursor.row, column - 2, cursor.row, column)), this.session.replace(range, swap), this.session.selection.moveToPosition(range.end); + } + } + }, this.toLowerCase = function() { + var originalRange = this.getSelectionRange(); + this.selection.isEmpty() && this.selection.selectWord(); + var range = this.getSelectionRange(), text = this.session.getTextRange(range); + this.session.replace(range, text.toLowerCase()), this.selection.setSelectionRange(originalRange); + }, this.toUpperCase = function() { + var originalRange = this.getSelectionRange(); + this.selection.isEmpty() && this.selection.selectWord(); + var range = this.getSelectionRange(), text = this.session.getTextRange(range); + this.session.replace(range, text.toUpperCase()), this.selection.setSelectionRange(originalRange); + }, this.indent = function() { + var session = this.session, range = this.getSelectionRange(); + if (range.start.row < range.end.row) { + var rows = this.$getSelectedRows(); + session.indentRows(rows.first, rows.last, "\t"); + return; + } + if (range.start.column < range.end.column) { + var text = session.getTextRange(range); + if (!/^\s+$/.test(text)) { + var rows = this.$getSelectedRows(); + session.indentRows(rows.first, rows.last, "\t"); + return; + } + } + var line = session.getLine(range.start.row), position = range.start, size = session.getTabSize(), column = session.documentToScreenColumn(position.row, position.column); + if (this.session.getUseSoftTabs()) var count = size - column % size, indentString = lang.stringRepeat(" ", count); + else { + for(var count = column % size; " " == line[range.start.column - 1] && count;)range.start.column--, count--; + this.selection.setSelectionRange(range), indentString = "\t"; + } + return this.insert(indentString); + }, this.blockIndent = function() { + var rows = this.$getSelectedRows(); + this.session.indentRows(rows.first, rows.last, "\t"); + }, this.blockOutdent = function() { + var selection = this.session.getSelection(); + this.session.outdentRows(selection.getRange()); + }, this.sortLines = function() { + for(var rows = this.$getSelectedRows(), session = this.session, lines = [], i = rows.first; i <= rows.last; i++)lines.push(session.getLine(i)); + lines.sort(function(a, b) { + return a.toLowerCase() < b.toLowerCase() ? -1 : a.toLowerCase() > b.toLowerCase() ? 1 : 0; + }); + for(var deleteRange = new Range(0, 0, 0, 0), i = rows.first; i <= rows.last; i++){ + var line = session.getLine(i); + deleteRange.start.row = i, deleteRange.end.row = i, deleteRange.end.column = line.length, session.replace(deleteRange, lines[i - rows.first]); + } + }, this.toggleCommentLines = function() { + var state = this.session.getState(this.getCursorPosition().row), rows = this.$getSelectedRows(); + this.session.getMode().toggleCommentLines(state, this.session, rows.first, rows.last); + }, this.toggleBlockComment = function() { + var cursor = this.getCursorPosition(), state = this.session.getState(cursor.row), range = this.getSelectionRange(); + this.session.getMode().toggleBlockComment(state, this.session, range, cursor); + }, this.getNumberAt = function(row, column) { + var _numberRx = /[\-]?[0-9]+(?:\.[0-9]+)?/g; + _numberRx.lastIndex = 0; + for(var s = this.session.getLine(row); _numberRx.lastIndex < column;){ + var m = _numberRx.exec(s); + if (m.index <= column && m.index + m[0].length >= column) return { + value: m[0], + start: m.index, + end: m.index + m[0].length + }; + } + return null; + }, this.modifyNumber = function(amount) { + var row = this.selection.getCursor().row, column = this.selection.getCursor().column, charRange = new Range(row, column - 1, row, column), c = this.session.getTextRange(charRange); + if (!isNaN(parseFloat(c)) && isFinite(c)) { + var nr = this.getNumberAt(row, column); + if (nr) { + var fp = nr.value.indexOf(".") >= 0 ? nr.start + nr.value.indexOf(".") + 1 : nr.end, decimals = nr.start + nr.value.length - fp, t = parseFloat(nr.value); + t *= Math.pow(10, decimals), fp !== nr.end && column < fp ? amount *= Math.pow(10, nr.end - column - 1) : amount *= Math.pow(10, nr.end - column), t += amount; + var nnr = (t /= Math.pow(10, decimals)).toFixed(decimals), replaceRange = new Range(row, nr.start, row, nr.end); + this.session.replace(replaceRange, nnr), this.moveCursorTo(row, Math.max(nr.start + 1, column + nnr.length - nr.value.length)); + } + } else this.toggleWord(); + }, this.$toggleWordPairs = [ + [ + "first", + "last" + ], + [ + "true", + "false" + ], + [ + "yes", + "no" + ], + [ + "width", + "height" + ], + [ + "top", + "bottom" + ], + [ + "right", + "left" + ], + [ + "on", + "off" + ], + [ + "x", + "y" + ], + [ + "get", + "set" + ], + [ + "max", + "min" + ], + [ + "horizontal", + "vertical" + ], + [ + "show", + "hide" + ], + [ + "add", + "remove" + ], + [ + "up", + "down" + ], + [ + "before", + "after" + ], + [ + "even", + "odd" + ], + [ + "in", + "out" + ], + [ + "inside", + "outside" + ], + [ + "next", + "previous" + ], + [ + "increase", + "decrease" + ], + [ + "attach", + "detach" + ], + [ + "&&", + "||" + ], + [ + "==", + "!=" + ] + ], this.toggleWord = function() { + var reg, row = this.selection.getCursor().row, column = this.selection.getCursor().column; + this.selection.selectWord(); + var currentState = this.getSelectedText(), currWordStart = this.selection.getWordRange().start.column, wordParts = currentState.replace(/([a-z]+|[A-Z]+)(?=[A-Z_]|$)/g, '$1 ').split(/\s/), delta = column - currWordStart - 1; + delta < 0 && (delta = 0); + var curLength = 0, itLength = 0, that = this; + currentState.match(/[A-Za-z0-9_]+/) && wordParts.forEach(function(item, i) { + itLength = curLength + item.length, delta >= curLength && delta <= itLength && (currentState = item, that.selection.clearSelection(), that.moveCursorTo(row, curLength + currWordStart), that.selection.selectTo(row, itLength + currWordStart)), curLength = itLength; + }); + for(var wordPairs = this.$toggleWordPairs, i = 0; i < wordPairs.length; i++)for(var item1 = wordPairs[i], j = 0; j <= 1; j++){ + var negate = +!j, firstCondition = currentState.match(new RegExp('^\\s?_?(' + lang.escapeRegExp(item1[j]) + ')\\s?$', 'i')); + firstCondition && currentState.match(new RegExp('([_]|^|\\s)(' + lang.escapeRegExp(firstCondition[1]) + ')($|\\s)', 'g')) && (reg = currentState.replace(new RegExp(lang.escapeRegExp(item1[j]), 'i'), function(result) { + var res = item1[negate]; + return result.toUpperCase() == result ? res = res.toUpperCase() : result.charAt(0).toUpperCase() == result.charAt(0) && (res = res.substr(0, 0) + item1[negate].charAt(0).toUpperCase() + res.substr(1)), res; + }), this.insert(reg), reg = ""); + } + }, this.removeLines = function() { + var rows = this.$getSelectedRows(); + this.session.removeFullLines(rows.first, rows.last), this.clearSelection(); + }, this.duplicateSelection = function() { + var sel = this.selection, doc = this.session, range = sel.getRange(), reverse = sel.isBackwards(); + if (range.isEmpty()) { + var row = range.start.row; + doc.duplicateLines(row, row); + } else { + var point = reverse ? range.start : range.end, endPoint = doc.insert(point, doc.getTextRange(range), !1); + range.start = point, range.end = endPoint, sel.setSelectionRange(range, reverse); + } + }, this.moveLinesDown = function() { + this.$moveLines(1, !1); + }, this.moveLinesUp = function() { + this.$moveLines(-1, !1); + }, this.moveText = function(range, toPosition, copy) { + return this.session.moveText(range, toPosition, copy); + }, this.copyLinesUp = function() { + this.$moveLines(-1, !0); + }, this.copyLinesDown = function() { + this.$moveLines(1, !0); + }, this.$moveLines = function(dir, copy) { + var rows, moved, selection = this.selection; + if (!selection.inMultiSelectMode || this.inVirtualSelectionMode) { + var range = selection.toOrientedRange(); + rows = this.$getSelectedRows(range), moved = this.session.$moveLines(rows.first, rows.last, copy ? 0 : dir), copy && -1 == dir && (moved = 0), range.moveBy(moved, 0), selection.fromOrientedRange(range); + } else { + var ranges = selection.rangeList.ranges; + selection.rangeList.detach(this.session), this.inVirtualSelectionMode = !0; + for(var diff = 0, totalDiff = 0, l = ranges.length, i = 0; i < l; i++){ + var rangeIndex = i; + ranges[i].moveBy(diff, 0); + for(var first = (rows = this.$getSelectedRows(ranges[i])).first, last = rows.last; ++i < l;){ + totalDiff && ranges[i].moveBy(totalDiff, 0); + var subRows = this.$getSelectedRows(ranges[i]); + if (copy && subRows.first != last) break; + if (!copy && subRows.first > last + 1) break; + last = subRows.last; + } + for(i--, diff = this.session.$moveLines(first, last, copy ? 0 : dir), copy && -1 == dir && (rangeIndex = i + 1); rangeIndex <= i;)ranges[rangeIndex].moveBy(diff, 0), rangeIndex++; + copy || (diff = 0), totalDiff += diff; + } + selection.fromOrientedRange(selection.ranges[0]), selection.rangeList.attach(this.session), this.inVirtualSelectionMode = !1; + } + }, this.$getSelectedRows = function(range) { + return range = (range || this.getSelectionRange()).collapseRows(), { + first: this.session.getRowFoldStart(range.start.row), + last: this.session.getRowFoldEnd(range.end.row) + }; + }, this.onCompositionStart = function(compositionState) { + this.renderer.showComposition(compositionState); + }, this.onCompositionUpdate = function(text) { + this.renderer.setCompositionText(text); + }, this.onCompositionEnd = function() { + this.renderer.hideComposition(); + }, this.getFirstVisibleRow = function() { + return this.renderer.getFirstVisibleRow(); + }, this.getLastVisibleRow = function() { + return this.renderer.getLastVisibleRow(); + }, this.isRowVisible = function(row) { + return row >= this.getFirstVisibleRow() && row <= this.getLastVisibleRow(); + }, this.isRowFullyVisible = function(row) { + return row >= this.renderer.getFirstFullyVisibleRow() && row <= this.renderer.getLastFullyVisibleRow(); + }, this.$getVisibleRowCount = function() { + return this.renderer.getScrollBottomRow() - this.renderer.getScrollTopRow() + 1; + }, this.$moveByPage = function(dir, select) { + var renderer = this.renderer, config = this.renderer.layerConfig, rows = dir * Math.floor(config.height / config.lineHeight); + !0 === select ? this.selection.$moveSelection(function() { + this.moveCursorBy(rows, 0); + }) : !1 === select && (this.selection.moveCursorBy(rows, 0), this.selection.clearSelection()); + var scrollTop = renderer.scrollTop; + renderer.scrollBy(0, rows * config.lineHeight), null != select && renderer.scrollCursorIntoView(null, 0.5), renderer.animateScrolling(scrollTop); + }, this.selectPageDown = function() { + this.$moveByPage(1, !0); + }, this.selectPageUp = function() { + this.$moveByPage(-1, !0); + }, this.gotoPageDown = function() { + this.$moveByPage(1, !1); + }, this.gotoPageUp = function() { + this.$moveByPage(-1, !1); + }, this.scrollPageDown = function() { + this.$moveByPage(1); + }, this.scrollPageUp = function() { + this.$moveByPage(-1); + }, this.scrollToRow = function(row) { + this.renderer.scrollToRow(row); + }, this.scrollToLine = function(line, center, animate, callback) { + this.renderer.scrollToLine(line, center, animate, callback); + }, this.centerSelection = function() { + var range = this.getSelectionRange(), pos = { + row: Math.floor(range.start.row + (range.end.row - range.start.row) / 2), + column: Math.floor(range.start.column + (range.end.column - range.start.column) / 2) + }; + this.renderer.alignCursor(pos, 0.5); + }, this.getCursorPosition = function() { + return this.selection.getCursor(); + }, this.getCursorPositionScreen = function() { + return this.session.documentToScreenPosition(this.getCursorPosition()); + }, this.getSelectionRange = function() { + return this.selection.getRange(); + }, this.selectAll = function() { + this.selection.selectAll(); + }, this.clearSelection = function() { + this.selection.clearSelection(); + }, this.moveCursorTo = function(row, column) { + this.selection.moveCursorTo(row, column); + }, this.moveCursorToPosition = function(pos) { + this.selection.moveCursorToPosition(pos); + }, this.jumpToMatching = function(select, expand) { + var matchType, bracketType, range, pos, cursor = this.getCursorPosition(), iterator = new TokenIterator(this.session, cursor.row, cursor.column), prevToken = iterator.getCurrentToken(), token = prevToken || iterator.stepForward(); + if (token) { + var found = !1, depth = {}, i = cursor.column - token.start, brackets = { + ")": "(", + "(": "(", + "]": "[", + "[": "[", + "{": "{", + "}": "{" + }; + do { + if (token.value.match(/[{}()\[\]]/g)) { + for(; i < token.value.length && !found; i++)if (brackets[token.value[i]]) switch(isNaN(depth[bracketType = brackets[token.value[i]] + '.' + token.type.replace("rparen", "lparen")]) && (depth[bracketType] = 0), token.value[i]){ + case '(': + case '[': + case '{': + depth[bracketType]++; + break; + case ')': + case ']': + case '}': + depth[bracketType]--, -1 === depth[bracketType] && (matchType = 'bracket', found = !0); + break; + } + } else -1 !== token.type.indexOf('tag-name') && (isNaN(depth[token.value]) && (depth[token.value] = 0), '<' === prevToken.value ? depth[token.value]++ : ' Math.abs(pos.column - cursor.column)) && (range = this.session.getBracketRange(pos))); + else if ('tag' === matchType) { + if (!token || -1 === token.type.indexOf('tag-name')) return; + var tag = token.value; + if (0 === (range = new Range(iterator.getCurrentTokenRow(), iterator.getCurrentTokenColumn() - 2, iterator.getCurrentTokenRow(), iterator.getCurrentTokenColumn() - 2)).compare(cursor.row, cursor.column)) { + found = !1; + do token = prevToken, (prevToken = iterator.stepBackward()) && (-1 !== prevToken.type.indexOf('tag-close') && range.setEnd(iterator.getCurrentTokenRow(), iterator.getCurrentTokenColumn() + 1), token.value === tag && -1 !== token.type.indexOf('tag-name') && ('<' === prevToken.value ? depth[tag]++ : ' Math.abs(pos.column - cursor.column) && (pos = range.end); + } + (pos = range && range.cursor || pos) && (select ? range && expand ? this.selection.setRange(range) : range && range.isEqual(this.getSelectionRange()) ? this.clearSelection() : this.selection.selectTo(pos.row, pos.column) : this.selection.moveTo(pos.row, pos.column)); + } + } + }, this.gotoLine = function(lineNumber, column, animate) { + this.selection.clearSelection(), this.session.unfold({ + row: lineNumber - 1, + column: column || 0 + }), this.exitMultiSelectMode && this.exitMultiSelectMode(), this.moveCursorTo(lineNumber - 1, column || 0), this.isRowFullyVisible(lineNumber - 1) || this.scrollToLine(lineNumber - 1, !0, animate); + }, this.navigateTo = function(row, column) { + this.selection.moveTo(row, column); + }, this.navigateUp = function(times) { + if (this.selection.isMultiLine() && !this.selection.isBackwards()) { + var selectionStart = this.selection.anchor.getPosition(); + return this.moveCursorToPosition(selectionStart); + } + this.selection.clearSelection(), this.selection.moveCursorBy(-times || -1, 0); + }, this.navigateDown = function(times) { + if (this.selection.isMultiLine() && this.selection.isBackwards()) { + var selectionEnd = this.selection.anchor.getPosition(); + return this.moveCursorToPosition(selectionEnd); + } + this.selection.clearSelection(), this.selection.moveCursorBy(times || 1, 0); + }, this.navigateLeft = function(times) { + if (this.selection.isEmpty()) for(times = times || 1; times--;)this.selection.moveCursorLeft(); + else { + var selectionStart = this.getSelectionRange().start; + this.moveCursorToPosition(selectionStart); + } + this.clearSelection(); + }, this.navigateRight = function(times) { + if (this.selection.isEmpty()) for(times = times || 1; times--;)this.selection.moveCursorRight(); + else { + var selectionEnd = this.getSelectionRange().end; + this.moveCursorToPosition(selectionEnd); + } + this.clearSelection(); + }, this.navigateLineStart = function() { + this.selection.moveCursorLineStart(), this.clearSelection(); + }, this.navigateLineEnd = function() { + this.selection.moveCursorLineEnd(), this.clearSelection(); + }, this.navigateFileEnd = function() { + this.selection.moveCursorFileEnd(), this.clearSelection(); + }, this.navigateFileStart = function() { + this.selection.moveCursorFileStart(), this.clearSelection(); + }, this.navigateWordRight = function() { + this.selection.moveCursorWordRight(), this.clearSelection(); + }, this.navigateWordLeft = function() { + this.selection.moveCursorWordLeft(), this.clearSelection(); + }, this.replace = function(replacement, options) { + options && this.$search.set(options); + var range = this.$search.find(this.session), replaced = 0; + return range && (this.$tryReplace(range, replacement) && (replaced = 1), this.selection.setSelectionRange(range), this.renderer.scrollSelectionIntoView(range.start, range.end)), replaced; + }, this.replaceAll = function(replacement, options) { + options && this.$search.set(options); + var ranges = this.$search.findAll(this.session), replaced = 0; + if (!ranges.length) return replaced; + var selection = this.getSelectionRange(); + this.selection.moveTo(0, 0); + for(var i = ranges.length - 1; i >= 0; --i)this.$tryReplace(ranges[i], replacement) && replaced++; + return this.selection.setSelectionRange(selection), replaced; + }, this.$tryReplace = function(range, replacement) { + var input = this.session.getTextRange(range); + return null !== (replacement = this.$search.replace(input, replacement)) ? (range.end = this.session.replace(range, replacement), range) : null; + }, this.getLastSearchOptions = function() { + return this.$search.getOptions(); + }, this.find = function(needle, options, animate) { + options || (options = {}), "string" == typeof needle || needle instanceof RegExp ? options.needle = needle : "object" == typeof needle && oop.mixin(options, needle); + var range = this.selection.getRange(); + null == options.needle && ((needle = this.session.getTextRange(range) || this.$search.$options.needle) || (range = this.session.getWordRange(range.start.row, range.start.column), needle = this.session.getTextRange(range)), this.$search.set({ + needle: needle + })), this.$search.set(options), options.start || this.$search.set({ + start: range + }); + var newRange = this.$search.find(this.session); + return options.preventScroll ? newRange : newRange ? (this.revealRange(newRange, animate), newRange) : void (options.backwards ? range.start = range.end : range.end = range.start, this.selection.setRange(range)); + }, this.findNext = function(options, animate) { + this.find({ + skipCurrent: !0, + backwards: !1 + }, options, animate); + }, this.findPrevious = function(options, animate) { + this.find(options, { + skipCurrent: !0, + backwards: !0 + }, animate); + }, this.revealRange = function(range, animate) { + this.session.unfold(range), this.selection.setSelectionRange(range); + var scrollTop = this.renderer.scrollTop; + this.renderer.scrollSelectionIntoView(range.start, range.end, 0.5), !1 !== animate && this.renderer.animateScrolling(scrollTop); + }, this.undo = function() { + this.session.getUndoManager().undo(this.session), this.renderer.scrollCursorIntoView(null, 0.5); + }, this.redo = function() { + this.session.getUndoManager().redo(this.session), this.renderer.scrollCursorIntoView(null, 0.5); + }, this.destroy = function() { + this.$toDestroy && (this.$toDestroy.forEach(function(el) { + el.destroy(); + }), this.$toDestroy = null), this.$mouseHandler && this.$mouseHandler.destroy(), this.renderer.destroy(), this._signal("destroy", this), this.session && this.session.destroy(), this._$emitInputEvent && this._$emitInputEvent.cancel(), this.removeAllListeners(); + }, this.setAutoScrollEditorIntoView = function(enable1) { + if (enable1) { + var rect, self = this, shouldScroll = !1; + this.$scrollAnchor || (this.$scrollAnchor = document.createElement("div")); + var scrollAnchor = this.$scrollAnchor; + scrollAnchor.style.cssText = "position:absolute", this.container.insertBefore(scrollAnchor, this.container.firstChild); + var onChangeSelection = this.on("changeSelection", function() { + shouldScroll = !0; + }), onBeforeRender = this.renderer.on("beforeRender", function() { + shouldScroll && (rect = self.renderer.container.getBoundingClientRect()); + }), onAfterRender = this.renderer.on("afterRender", function() { + if (shouldScroll && rect && (self.isFocused() || self.searchBox && self.searchBox.isFocused())) { + var renderer = self.renderer, pos = renderer.$cursorLayer.$pixelPos, config = renderer.layerConfig, top = pos.top - config.offset; + null != (shouldScroll = pos.top >= 0 && top + rect.top < 0 || (!(pos.top < config.height) || !(pos.top + rect.top + config.lineHeight > window.innerHeight)) && null) && (scrollAnchor.style.top = top + "px", scrollAnchor.style.left = pos.left + "px", scrollAnchor.style.height = config.lineHeight + "px", scrollAnchor.scrollIntoView(shouldScroll)), shouldScroll = rect = null; + } + }); + this.setAutoScrollEditorIntoView = function(enable) { + enable || (delete this.setAutoScrollEditorIntoView, this.off("changeSelection", onChangeSelection), this.renderer.off("afterRender", onAfterRender), this.renderer.off("beforeRender", onBeforeRender)); + }; + } + }, this.$resetCursorStyle = function() { + var style = this.$cursorStyle || "ace", cursorLayer = this.renderer.$cursorLayer; + cursorLayer && (cursorLayer.setSmoothBlinking(/smooth/.test(style)), cursorLayer.isBlinking = !this.$readOnly && "wide" != style, dom.setCssClass(cursorLayer.element, "ace_slim-cursors", /slim/.test(style))); + }, this.prompt = function(message, options, callback) { + var editor = this; + config1.loadModule("./ext/prompt", function(module) { + module.prompt(editor, message, options, callback); + }); + }; + }).call(Editor.prototype), config1.defineOptions(Editor.prototype, "editor", { + selectionStyle: { + set: function(style) { + this.onSelectionChange(), this._signal("changeSelectionStyle", { + data: style + }); + }, + initialValue: "line" + }, + highlightActiveLine: { + set: function() { + this.$updateHighlightActiveLine(); + }, + initialValue: !0 + }, + highlightSelectedWord: { + set: function(shouldHighlight) { + this.$onSelectionChange(); + }, + initialValue: !0 + }, + readOnly: { + set: function(readOnly) { + this.textInput.setReadOnly(readOnly), this.$resetCursorStyle(); + }, + initialValue: !1 + }, + copyWithEmptySelection: { + set: function(value) { + this.textInput.setCopyWithEmptySelection(value); + }, + initialValue: !1 + }, + cursorStyle: { + set: function(val) { + this.$resetCursorStyle(); + }, + values: [ + "ace", + "slim", + "smooth", + "wide" + ], + initialValue: "ace" + }, + mergeUndoDeltas: { + values: [ + !1, + !0, + "always" + ], + initialValue: !0 + }, + behavioursEnabled: { + initialValue: !0 + }, + wrapBehavioursEnabled: { + initialValue: !0 + }, + enableAutoIndent: { + initialValue: !0 + }, + autoScrollEditorIntoView: { + set: function(val) { + this.setAutoScrollEditorIntoView(val); + } + }, + keyboardHandler: { + set: function(val) { + this.setKeyboardHandler(val); + }, + get: function() { + return this.$keybindingId; + }, + handlesSet: !0 + }, + value: { + set: function(val) { + this.session.setValue(val); + }, + get: function() { + return this.getValue(); + }, + handlesSet: !0, + hidden: !0 + }, + session: { + set: function(val) { + this.setSession(val); + }, + get: function() { + return this.session; + }, + handlesSet: !0, + hidden: !0 + }, + showLineNumbers: { + set: function(show) { + this.renderer.$gutterLayer.setShowLineNumbers(show), this.renderer.$loop.schedule(this.renderer.CHANGE_GUTTER), show && this.$relativeLineNumbers ? relativeNumberRenderer.attach(this) : relativeNumberRenderer.detach(this); + }, + initialValue: !0 + }, + relativeLineNumbers: { + set: function(value) { + this.$showLineNumbers && value ? relativeNumberRenderer.attach(this) : relativeNumberRenderer.detach(this); + } + }, + placeholder: { + set: function(message) { + this.$updatePlaceholder || (this.$updatePlaceholder = (function() { + var value = this.session && (this.renderer.$composition || this.getValue()); + if (value && this.renderer.placeholderNode) this.renderer.off("afterRender", this.$updatePlaceholder), dom.removeCssClass(this.container, "ace_hasPlaceholder"), this.renderer.placeholderNode.remove(), this.renderer.placeholderNode = null; + else if (value || this.renderer.placeholderNode) !value && this.renderer.placeholderNode && (this.renderer.placeholderNode.textContent = this.$placeholder || ""); + else { + this.renderer.on("afterRender", this.$updatePlaceholder), dom.addCssClass(this.container, "ace_hasPlaceholder"); + var el = dom.createElement("div"); + el.className = "ace_placeholder", el.textContent = this.$placeholder || "", this.renderer.placeholderNode = el, this.renderer.content.appendChild(this.renderer.placeholderNode); + } + }).bind(this), this.on("input", this.$updatePlaceholder)), this.$updatePlaceholder(); + } + }, + hScrollBarAlwaysVisible: "renderer", + vScrollBarAlwaysVisible: "renderer", + highlightGutterLine: "renderer", + animatedScroll: "renderer", + showInvisibles: "renderer", + showPrintMargin: "renderer", + printMarginColumn: "renderer", + printMargin: "renderer", + fadeFoldWidgets: "renderer", + showFoldWidgets: "renderer", + displayIndentGuides: "renderer", + showGutter: "renderer", + fontSize: "renderer", + fontFamily: "renderer", + maxLines: "renderer", + minLines: "renderer", + scrollPastEnd: "renderer", + fixedWidthGutter: "renderer", + theme: "renderer", + hasCssTransforms: "renderer", + maxPixelHeight: "renderer", + useTextareaForIME: "renderer", + scrollSpeed: "$mouseHandler", + dragDelay: "$mouseHandler", + dragEnabled: "$mouseHandler", + focusTimeout: "$mouseHandler", + tooltipFollowsMouse: "$mouseHandler", + firstLineNumber: "session", + overwrite: "session", + newLineMode: "session", + useWorker: "session", + useSoftTabs: "session", + navigateWithinSoftTabs: "session", + tabSize: "session", + wrap: "session", + indentedSoftWrap: "session", + foldStyle: "session", + mode: "session" + }); + var relativeNumberRenderer = { + getText: function(session, row) { + return (Math.abs(session.selection.lead.row - row) || row + 1 + (row < 9 ? "\xb7" : "")) + ""; + }, + getWidth: function(session, lastLineNumber, config) { + return Math.max(lastLineNumber.toString().length, (config.lastRow + 1).toString().length, 2) * config.characterWidth; + }, + update: function(e, editor) { + editor.renderer.$loop.schedule(editor.renderer.CHANGE_GUTTER); + }, + attach: function(editor) { + editor.renderer.$gutterLayer.$renderer = this, editor.on("changeSelection", this.update), this.update(null, editor); + }, + detach: function(editor) { + editor.renderer.$gutterLayer.$renderer == this && (editor.renderer.$gutterLayer.$renderer = null), editor.off("changeSelection", this.update), this.update(null, editor); + } + }; + exports.Editor = Editor; + }), ace.define("ace/undomanager", [ + "require", + "exports", + "module", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var UndoManager = function() { + this.$maxRev = 0, this.$fromUndo = !1, this.reset(); + }; + (function() { + this.addSession = function(session) { + this.$session = session; + }, this.add = function(delta, allowMerge, session) { + this.$fromUndo || delta != this.$lastDelta && (this.$keepRedoStack || (this.$redoStack.length = 0), !1 !== allowMerge && this.lastDeltas || (this.lastDeltas = [], this.$undoStack.push(this.lastDeltas), delta.id = this.$rev = ++this.$maxRev), ("remove" == delta.action || "insert" == delta.action) && (this.$lastDelta = delta), this.lastDeltas.push(delta)); + }, this.addSelection = function(selection, rev) { + this.selections.push({ + value: selection, + rev: rev || this.$rev + }); + }, this.startNewGroup = function() { + return this.lastDeltas = null, this.$rev; + }, this.markIgnored = function(from, to) { + null == to && (to = this.$rev + 1); + for(var stack = this.$undoStack, i = stack.length; i--;){ + var delta = stack[i][0]; + if (delta.id <= from) break; + delta.id < to && (delta.ignore = !0); + } + this.lastDeltas = null; + }, this.getSelection = function(rev, after) { + for(var stack = this.selections, i = stack.length; i--;){ + var selection = stack[i]; + if (selection.rev < rev) return after && (selection = stack[i + 1]), selection; + } + }, this.getRevision = function() { + return this.$rev; + }, this.getDeltas = function(from, to) { + null == to && (to = this.$rev + 1); + for(var stack = this.$undoStack, end = null, start = 0, i = stack.length; i--;){ + var delta = stack[i][0]; + if (delta.id < to && !end && (end = i + 1), delta.id <= from) { + start = i + 1; + break; + } + } + return stack.slice(start, end); + }, this.getChangedRanges = function(from, to) { + null == to && (to = this.$rev + 1); + }, this.getChangedLines = function(from, to) { + null == to && (to = this.$rev + 1); + }, this.undo = function(session, dontSelect) { + this.lastDeltas = null; + var stack1 = this.$undoStack; + if (function(stack, pos) { + for(var i = pos; i--;){ + var deltaSet = stack[i]; + if (deltaSet && !deltaSet[0].ignore) { + for(; i < pos - 1;){ + var swapped = swapGroups(stack[i], stack[i + 1]); + stack[i] = swapped[0], stack[i + 1] = swapped[1], i++; + } + return !0; + } + } + }(stack1, stack1.length)) { + session || (session = this.$session), this.$redoStackBaseRev !== this.$rev && this.$redoStack.length && (this.$redoStack = []), this.$fromUndo = !0; + var deltaSet1 = stack1.pop(), undoSelectionRange = null; + return deltaSet1 && (undoSelectionRange = session.undoChanges(deltaSet1, dontSelect), this.$redoStack.push(deltaSet1), this.$syncRev()), this.$fromUndo = !1, undoSelectionRange; + } + }, this.redo = function(session, dontSelect) { + if (this.lastDeltas = null, session || (session = this.$session), this.$fromUndo = !0, this.$redoStackBaseRev != this.$rev) { + var diff = this.getDeltas(this.$redoStackBaseRev, this.$rev + 1); + rebaseRedoStack(this.$redoStack, diff), this.$redoStackBaseRev = this.$rev, this.$redoStack.forEach(function(x) { + x[0].id = ++this.$maxRev; + }, this); + } + var deltaSet = this.$redoStack.pop(), redoSelectionRange = null; + return deltaSet && (redoSelectionRange = session.redoChanges(deltaSet, dontSelect), this.$undoStack.push(deltaSet), this.$syncRev()), this.$fromUndo = !1, redoSelectionRange; + }, this.$syncRev = function() { + var stack = this.$undoStack, nextDelta = stack[stack.length - 1], id = nextDelta && nextDelta[0].id || 0; + this.$redoStackBaseRev = id, this.$rev = id; + }, this.reset = function() { + this.lastDeltas = null, this.$lastDelta = null, this.$undoStack = [], this.$redoStack = [], this.$rev = 0, this.mark = 0, this.$redoStackBaseRev = this.$rev, this.selections = []; + }, this.canUndo = function() { + return this.$undoStack.length > 0; + }, this.canRedo = function() { + return this.$redoStack.length > 0; + }, this.bookmark = function(rev) { + void 0 == rev && (rev = this.$rev), this.mark = rev; + }, this.isAtBookmark = function() { + return this.$rev === this.mark; + }, this.toJSON = function() {}, this.fromJSON = function() {}, this.hasUndo = this.canUndo, this.hasRedo = this.canRedo, this.isClean = this.isAtBookmark, this.markClean = this.bookmark, this.$prettyPrint = function(delta) { + return delta ? stringifyDelta(delta) : stringifyDelta(this.$undoStack) + "\n---\n" + stringifyDelta(this.$redoStack); + }; + }).call(UndoManager.prototype); + var Range = require("./range").Range, cmp = Range.comparePoints; + function clonePos(pos) { + return { + row: pos.row, + column: pos.column + }; + } + function stringifyDelta(d) { + if (d = d || this, Array.isArray(d)) return d.map(stringifyDelta).join("\n"); + var type = ""; + return d.action ? (type = "insert" == d.action ? "+" : "-", type += "[" + d.lines + "]") : d.value && (type = Array.isArray(d.value) ? d.value.map(stringifyRange).join("\n") : stringifyRange(d.value)), d.start && (type += stringifyRange(d)), (d.id || d.rev) && (type += "\t(" + (d.id || d.rev) + ")"), type; + } + function stringifyRange(r) { + return r.start.row + ":" + r.start.column + "=>" + r.end.row + ":" + r.end.column; + } + function swap(d1, d2) { + var i1 = "insert" == d1.action, i2 = "insert" == d2.action; + if (i1 && i2) if (cmp(d2.start, d1.end) >= 0) shift(d2, d1, -1); + else { + if (!(0 >= cmp(d2.start, d1.start))) return null; + shift(d1, d2, 1); + } + else if (i1 && !i2) if (cmp(d2.start, d1.end) >= 0) shift(d2, d1, -1); + else { + if (!(0 >= cmp(d2.end, d1.start))) return null; + shift(d1, d2, -1); + } + else if (!i1 && i2) if (cmp(d2.start, d1.start) >= 0) shift(d2, d1, 1); + else { + if (!(0 >= cmp(d2.start, d1.start))) return null; + shift(d1, d2, 1); + } + else if (!i1 && !i2) if (cmp(d2.start, d1.start) >= 0) shift(d2, d1, 1); + else { + if (!(0 >= cmp(d2.end, d1.start))) return null; + shift(d1, d2, -1); + } + return [ + d2, + d1 + ]; + } + function swapGroups(ds1, ds2) { + for(var i = ds1.length; i--;)for(var j = 0; j < ds2.length; j++)if (!swap(ds1[i], ds2[j])) { + for(; i < ds1.length;){ + for(; j--;)swap(ds2[j], ds1[i]); + j = ds2.length, i++; + } + return [ + ds1, + ds2 + ]; + } + return ds1.selectionBefore = ds2.selectionBefore = ds1.selectionAfter = ds2.selectionAfter = null, [ + ds2, + ds1 + ]; + } + function xform(d1, c1) { + var before, after, i1 = "insert" == d1.action, i2 = "insert" == c1.action; + if (i1 && i2) 0 > cmp(d1.start, c1.start) ? shift(c1, d1, 1) : shift(d1, c1, 1); + else if (i1 && !i2) cmp(d1.start, c1.end) >= 0 ? shift(d1, c1, -1) : (0 >= cmp(d1.start, c1.start) || shift(d1, Range.fromPoints(c1.start, d1.start), -1), shift(c1, d1, 1)); + else if (!i1 && i2) cmp(c1.start, d1.end) >= 0 ? shift(c1, d1, -1) : (0 >= cmp(c1.start, d1.start) || shift(c1, Range.fromPoints(d1.start, c1.start), -1), shift(d1, c1, 1)); + else if (!i1 && !i2) if (cmp(c1.start, d1.end) >= 0) shift(c1, d1, -1); + else { + if (!(0 >= cmp(c1.end, d1.start))) return 0 > cmp(d1.start, c1.start) && (before = d1, d1 = splitDelta(d1, c1.start)), cmp(d1.end, c1.end) > 0 && (after = splitDelta(d1, c1.end)), shiftPos(c1.end, d1.start, d1.end, -1), after && !before && (d1.lines = after.lines, d1.start = after.start, d1.end = after.end, after = d1), [ + c1, + before, + after + ].filter(Boolean); + shift(d1, c1, -1); + } + return [ + c1, + d1 + ]; + } + function shift(d1, d2, dir) { + shiftPos(d1.start, d2.start, d2.end, dir), shiftPos(d1.end, d2.start, d2.end, dir); + } + function shiftPos(pos, start, end, dir) { + pos.row == (1 == dir ? start : end).row && (pos.column += dir * (end.column - start.column)), pos.row += dir * (end.row - start.row); + } + function splitDelta(c, pos) { + var lines = c.lines, end = c.end; + c.end = clonePos(pos); + var rowsBefore = c.end.row - c.start.row, otherLines = lines.splice(rowsBefore, lines.length), col = rowsBefore ? pos.column : pos.column - c.start.column; + lines.push(otherLines[0].substring(0, col)), otherLines[0] = otherLines[0].substr(col); + var rest = { + start: clonePos(pos), + end: end, + lines: otherLines, + action: c.action + }; + return rest; + } + function moveDeltasByOne(redoStack, d) { + var d3; + d = { + start: clonePos((d3 = d).start), + end: clonePos(d3.end), + action: d3.action, + lines: d3.lines.slice() + }; + for(var j = redoStack.length; j--;){ + for(var deltaSet = redoStack[j], i = 0; i < deltaSet.length; i++){ + var xformed = xform(deltaSet[i], d); + d = xformed[0], 2 != xformed.length && (xformed[2] ? (deltaSet.splice(i + 1, 1, xformed[1], xformed[2]), i++) : !xformed[1] && (deltaSet.splice(i, 1), i--)); + } + deltaSet.length || redoStack.splice(j, 1); + } + return redoStack; + } + function rebaseRedoStack(redoStack, deltaSets) { + for(var i = 0; i < deltaSets.length; i++)for(var deltas = deltaSets[i], j = 0; j < deltas.length; j++)moveDeltasByOne(redoStack, deltas[j]); + } + Range.comparePoints, exports.UndoManager = UndoManager; + }), ace.define("ace/layer/lines", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"), Lines = function(element, canvasHeight) { + this.element = element, this.canvasHeight = canvasHeight || 500000, this.element.style.height = 2 * this.canvasHeight + "px", this.cells = [], this.cellCache = [], this.$offsetCoefficient = 0; + }; + (function() { + this.moveContainer = function(config) { + dom.translate(this.element, 0, -(config.firstRowScreen * config.lineHeight % this.canvasHeight) - config.offset * this.$offsetCoefficient); + }, this.pageChanged = function(oldConfig, newConfig) { + return Math.floor(oldConfig.firstRowScreen * oldConfig.lineHeight / this.canvasHeight) !== Math.floor(newConfig.firstRowScreen * newConfig.lineHeight / this.canvasHeight); + }, this.computeLineTop = function(row, config, session) { + var screenPage = Math.floor(config.firstRowScreen * config.lineHeight / this.canvasHeight); + return session.documentToScreenRow(row, 0) * config.lineHeight - screenPage * this.canvasHeight; + }, this.computeLineHeight = function(row, config, session) { + return config.lineHeight * session.getRowLineCount(row); + }, this.getLength = function() { + return this.cells.length; + }, this.get = function(index) { + return this.cells[index]; + }, this.shift = function() { + this.$cacheCell(this.cells.shift()); + }, this.pop = function() { + this.$cacheCell(this.cells.pop()); + }, this.push = function(cell) { + if (Array.isArray(cell)) { + this.cells.push.apply(this.cells, cell); + for(var fragment = dom.createFragment(this.element), i = 0; i < cell.length; i++)fragment.appendChild(cell[i].element); + this.element.appendChild(fragment); + } else this.cells.push(cell), this.element.appendChild(cell.element); + }, this.unshift = function(cell) { + if (Array.isArray(cell)) { + this.cells.unshift.apply(this.cells, cell); + for(var fragment = dom.createFragment(this.element), i = 0; i < cell.length; i++)fragment.appendChild(cell[i].element); + this.element.firstChild ? this.element.insertBefore(fragment, this.element.firstChild) : this.element.appendChild(fragment); + } else this.cells.unshift(cell), this.element.insertAdjacentElement("afterbegin", cell.element); + }, this.last = function() { + return this.cells.length ? this.cells[this.cells.length - 1] : null; + }, this.$cacheCell = function(cell) { + cell && (cell.element.remove(), this.cellCache.push(cell)); + }, this.createCell = function(row, config, session, initElement) { + var cell = this.cellCache.pop(); + if (!cell) { + var element = dom.createElement("div"); + initElement && initElement(element), this.element.appendChild(element), cell = { + element: element, + text: "", + row: row + }; + } + return cell.row = row, cell; + }; + }).call(Lines.prototype), exports.Lines = Lines; + }), ace.define("ace/layer/gutter", [ + "require", + "exports", + "module", + "ace/lib/dom", + "ace/lib/oop", + "ace/lib/lang", + "ace/lib/event_emitter", + "ace/layer/lines" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"), oop = require("../lib/oop"), lang = require("../lib/lang"), EventEmitter = require("../lib/event_emitter").EventEmitter, Lines = require("./lines").Lines, Gutter = function(parentEl) { + this.element = dom.createElement("div"), this.element.className = "ace_layer ace_gutter-layer", parentEl.appendChild(this.element), this.setShowFoldWidgets(this.$showFoldWidgets), this.gutterWidth = 0, this.$annotations = [], this.$updateAnnotations = this.$updateAnnotations.bind(this), this.$lines = new Lines(this.element), this.$lines.$offsetCoefficient = 1; + }; + function onCreateCell(element) { + var textNode = document.createTextNode(''); + element.appendChild(textNode); + var foldWidget = dom.createElement("span"); + return element.appendChild(foldWidget), element; + } + (function() { + oop.implement(this, EventEmitter), this.setSession = function(session) { + this.session && this.session.off("change", this.$updateAnnotations), this.session = session, session && session.on("change", this.$updateAnnotations); + }, this.addGutterDecoration = function(row, className) { + window.console && console.warn && console.warn("deprecated use session.addGutterDecoration"), this.session.addGutterDecoration(row, className); + }, this.removeGutterDecoration = function(row, className) { + window.console && console.warn && console.warn("deprecated use session.removeGutterDecoration"), this.session.removeGutterDecoration(row, className); + }, this.setAnnotations = function(annotations) { + this.$annotations = []; + for(var i = 0; i < annotations.length; i++){ + var annotation = annotations[i], row = annotation.row, rowInfo = this.$annotations[row]; + rowInfo || (rowInfo = this.$annotations[row] = { + text: [] + }); + var annoText = annotation.text; + annoText = annoText ? lang.escapeHTML(annoText) : annotation.html || "", -1 === rowInfo.text.indexOf(annoText) && rowInfo.text.push(annoText); + var type = annotation.type; + "error" == type ? rowInfo.className = " ace_error" : "warning" == type && " ace_error" != rowInfo.className ? rowInfo.className = " ace_warning" : "info" != type || rowInfo.className || (rowInfo.className = " ace_info"); + } + }, this.$updateAnnotations = function(delta) { + if (this.$annotations.length) { + var firstRow = delta.start.row, len = delta.end.row - firstRow; + if (0 === len) ; + else if ('remove' == delta.action) this.$annotations.splice(firstRow, len + 1, null); + else { + var args = new Array(len + 1); + args.unshift(firstRow, 1), this.$annotations.splice.apply(this.$annotations, args); + } + } + }, this.update = function(config) { + this.config = config; + var session = this.session, firstRow = config.firstRow, lastRow = Math.min(config.lastRow + config.gutterOffset, session.getLength() - 1); + this.oldLastRow = lastRow, this.config = config, this.$lines.moveContainer(config), this.$updateCursorRow(); + for(var fold = session.getNextFoldLine(firstRow), foldStart = fold ? fold.start.row : 1 / 0, cell = null, index = -1, row = firstRow;;){ + if (row > foldStart && (row = fold.end.row + 1, foldStart = (fold = session.getNextFoldLine(row, fold)) ? fold.start.row : 1 / 0), row > lastRow) { + for(; this.$lines.getLength() > index + 1;)this.$lines.pop(); + break; + } + (cell = this.$lines.get(++index)) ? cell.row = row : (cell = this.$lines.createCell(row, config, this.session, onCreateCell), this.$lines.push(cell)), this.$renderCell(cell, config, fold, row), row++; + } + this._signal("afterRender"), this.$updateGutterWidth(config); + }, this.$updateGutterWidth = function(config) { + var session = this.session, gutterRenderer = session.gutterRenderer || this.$renderer, firstLineNumber = session.$firstLineNumber, lastLineText = this.$lines.last() ? this.$lines.last().text : ""; + (this.$fixedWidth || session.$useWrapMode) && (lastLineText = session.getLength() + firstLineNumber - 1); + var gutterWidth = gutterRenderer ? gutterRenderer.getWidth(session, lastLineText, config) : lastLineText.toString().length * config.characterWidth, padding = this.$padding || this.$computePadding(); + (gutterWidth += padding.left + padding.right) === this.gutterWidth || isNaN(gutterWidth) || (this.gutterWidth = gutterWidth, this.element.parentNode.style.width = this.element.style.width = Math.ceil(this.gutterWidth) + "px", this._signal("changeGutterWidth", gutterWidth)); + }, this.$updateCursorRow = function() { + if (this.$highlightGutterLine) { + var position = this.session.selection.getCursor(); + this.$cursorRow !== position.row && (this.$cursorRow = position.row); + } + }, this.updateLineHighlight = function() { + if (this.$highlightGutterLine) { + var row = this.session.selection.cursor.row; + if (this.$cursorRow = row, !this.$cursorCell || this.$cursorCell.row != row) { + this.$cursorCell && (this.$cursorCell.element.className = this.$cursorCell.element.className.replace("ace_gutter-active-line ", "")); + var cells = this.$lines.cells; + this.$cursorCell = null; + for(var i = 0; i < cells.length; i++){ + var cell = cells[i]; + if (cell.row >= this.$cursorRow) { + if (cell.row > this.$cursorRow) { + var fold = this.session.getFoldLine(this.$cursorRow); + if (i > 0 && fold && fold.start.row == cells[i - 1].row) cell = cells[i - 1]; + else break; + } + cell.element.className = "ace_gutter-active-line " + cell.element.className, this.$cursorCell = cell; + break; + } + } + } + } + }, this.scrollLines = function(config) { + var oldConfig = this.config; + if (this.config = config, this.$updateCursorRow(), this.$lines.pageChanged(oldConfig, config)) return this.update(config); + this.$lines.moveContainer(config); + var lastRow = Math.min(config.lastRow + config.gutterOffset, this.session.getLength() - 1), oldLastRow = this.oldLastRow; + if (this.oldLastRow = lastRow, !oldConfig || oldLastRow < config.firstRow) return this.update(config); + if (lastRow < oldConfig.firstRow) return this.update(config); + if (oldConfig.firstRow < config.firstRow) for(var row = this.session.getFoldedRowCount(oldConfig.firstRow, config.firstRow - 1); row > 0; row--)this.$lines.shift(); + if (oldLastRow > lastRow) for(var row = this.session.getFoldedRowCount(lastRow + 1, oldLastRow); row > 0; row--)this.$lines.pop(); + config.firstRow < oldConfig.firstRow && this.$lines.unshift(this.$renderLines(config, config.firstRow, oldConfig.firstRow - 1)), lastRow > oldLastRow && this.$lines.push(this.$renderLines(config, oldLastRow + 1, lastRow)), this.updateLineHighlight(), this._signal("afterRender"), this.$updateGutterWidth(config); + }, this.$renderLines = function(config, firstRow, lastRow) { + for(var fragment = [], row = firstRow, foldLine = this.session.getNextFoldLine(row), foldStart = foldLine ? foldLine.start.row : 1 / 0; row > foldStart && (row = foldLine.end.row + 1, foldStart = (foldLine = this.session.getNextFoldLine(row, foldLine)) ? foldLine.start.row : 1 / 0), !(row > lastRow);){ + var cell = this.$lines.createCell(row, config, this.session, onCreateCell); + this.$renderCell(cell, config, foldLine, row), fragment.push(cell), row++; + } + return fragment; + }, this.$renderCell = function(cell, config, fold, row) { + var element = cell.element, session = this.session, textNode = element.childNodes[0], foldWidget = element.childNodes[1], firstLineNumber = session.$firstLineNumber, breakpoints = session.$breakpoints, decorations = session.$decorations, gutterRenderer = session.gutterRenderer || this.$renderer, foldWidgets = this.$showFoldWidgets && session.foldWidgets, foldStart = fold ? fold.start.row : Number.MAX_VALUE, className = "ace_gutter-cell "; + if (this.$highlightGutterLine && (row == this.$cursorRow || fold && row < this.$cursorRow && row >= foldStart && this.$cursorRow <= fold.end.row) && (className += "ace_gutter-active-line ", this.$cursorCell != cell && (this.$cursorCell && (this.$cursorCell.element.className = this.$cursorCell.element.className.replace("ace_gutter-active-line ", "")), this.$cursorCell = cell)), breakpoints[row] && (className += breakpoints[row]), decorations[row] && (className += decorations[row]), this.$annotations[row] && (className += this.$annotations[row].className), element.className != className && (element.className = className), foldWidgets) { + var c = foldWidgets[row]; + null == c && (c = foldWidgets[row] = session.getFoldWidget(row)); + } + if (c) { + var className = "ace_fold-widget ace_" + c; + "start" == c && row == foldStart && row < fold.end.row ? className += " ace_closed" : className += " ace_open", foldWidget.className != className && (foldWidget.className = className); + var foldHeight = config.lineHeight + "px"; + dom.setStyle(foldWidget.style, "height", foldHeight), dom.setStyle(foldWidget.style, "display", "inline-block"); + } else foldWidget && dom.setStyle(foldWidget.style, "display", "none"); + var text = (gutterRenderer ? gutterRenderer.getText(session, row) : row + firstLineNumber).toString(); + return text !== textNode.data && (textNode.data = text), dom.setStyle(cell.element.style, "height", this.$lines.computeLineHeight(row, config, session) + "px"), dom.setStyle(cell.element.style, "top", this.$lines.computeLineTop(row, config, session) + "px"), cell.text = text, cell; + }, this.$fixedWidth = !1, this.$highlightGutterLine = !0, this.$renderer = "", this.setHighlightGutterLine = function(highlightGutterLine) { + this.$highlightGutterLine = highlightGutterLine; + }, this.$showLineNumbers = !0, this.$renderer = "", this.setShowLineNumbers = function(show) { + this.$renderer = !show && { + getWidth: function() { + return 0; + }, + getText: function() { + return ""; + } + }; + }, this.getShowLineNumbers = function() { + return this.$showLineNumbers; + }, this.$showFoldWidgets = !0, this.setShowFoldWidgets = function(show) { + show ? dom.addCssClass(this.element, "ace_folding-enabled") : dom.removeCssClass(this.element, "ace_folding-enabled"), this.$showFoldWidgets = show, this.$padding = null; + }, this.getShowFoldWidgets = function() { + return this.$showFoldWidgets; + }, this.$computePadding = function() { + if (!this.element.firstChild) return { + left: 0, + right: 0 + }; + var style = dom.computedStyle(this.element.firstChild); + return this.$padding = {}, this.$padding.left = (parseInt(style.borderLeftWidth) || 0) + (parseInt(style.paddingLeft) || 0) + 1, this.$padding.right = (parseInt(style.borderRightWidth) || 0) + (parseInt(style.paddingRight) || 0), this.$padding; + }, this.getRegion = function(point) { + var padding = this.$padding || this.$computePadding(), rect = this.element.getBoundingClientRect(); + return point.x < padding.left + rect.left ? "markers" : this.$showFoldWidgets && point.x > rect.right - padding.right ? "foldWidgets" : void 0; + }; + }).call(Gutter.prototype), exports.Gutter = Gutter; + }), ace.define("ace/layer/marker", [ + "require", + "exports", + "module", + "ace/range", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var Range = require("../range").Range, dom = require("../lib/dom"), Marker = function(parentEl) { + this.element = dom.createElement("div"), this.element.className = "ace_layer ace_marker-layer", parentEl.appendChild(this.element); + }; + (function() { + function getBorderClass(tl, tr, br, bl) { + return (tl ? 1 : 0) | (tr ? 2 : 0) | (br ? 4 : 0) | (bl ? 8 : 0); + } + this.$padding = 0, this.setPadding = function(padding) { + this.$padding = padding; + }, this.setSession = function(session) { + this.session = session; + }, this.setMarkers = function(markers) { + this.markers = markers; + }, this.elt = function(className, css) { + var x = -1 != this.i && this.element.childNodes[this.i]; + x ? this.i++ : (x = document.createElement("div"), this.element.appendChild(x), this.i = -1), x.style.cssText = css, x.className = className; + }, this.update = function(config) { + if (config) { + for(var key in this.config = config, this.i = 0, this.markers){ + var html, marker = this.markers[key]; + if (!marker.range) { + marker.update(html, this, this.session, config); + continue; + } + var range = marker.range.clipRows(config.firstRow, config.lastRow); + if (!range.isEmpty()) if (range = range.toScreenRange(this.session), marker.renderer) { + var top = this.$getTop(range.start.row, config), left = this.$padding + range.start.column * config.characterWidth; + marker.renderer(html, range, left, top, config); + } else "fullLine" == marker.type ? this.drawFullLineMarker(html, range, marker.clazz, config) : "screenLine" == marker.type ? this.drawScreenLineMarker(html, range, marker.clazz, config) : range.isMultiLine() ? "text" == marker.type ? this.drawTextMarker(html, range, marker.clazz, config) : this.drawMultiLineMarker(html, range, marker.clazz, config) : this.drawSingleLineMarker(html, range, marker.clazz + " ace_start ace_br15", config); + } + if (-1 != this.i) for(; this.i < this.element.childElementCount;)this.element.removeChild(this.element.lastChild); + } + }, this.$getTop = function(row, layerConfig) { + return (row - layerConfig.firstRowScreen) * layerConfig.lineHeight; + }, this.drawTextMarker = function(stringBuilder, range, clazz, layerConfig, extraStyle) { + for(var session = this.session, start = range.start.row, end = range.end.row, row = start, prev = 0, curr = 0, next = session.getScreenLastRowColumn(row), lineRange = new Range(row, range.start.column, row, curr); row <= end; row++)lineRange.start.row = lineRange.end.row = row, lineRange.start.column = row == start ? range.start.column : session.getRowWrapIndent(row), lineRange.end.column = next, prev = curr, curr = next, next = row + 1 < end ? session.getScreenLastRowColumn(row + 1) : row == end ? 0 : range.end.column, this.drawSingleLineMarker(stringBuilder, lineRange, clazz + (row == start ? " ace_start" : "") + " ace_br" + getBorderClass(row == start || row == start + 1 && range.start.column, prev < curr, curr > next, row == end), layerConfig, row == end ? 0 : 1, extraStyle); + }, this.drawMultiLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var padding = this.$padding, height = config.lineHeight, top = this.$getTop(range.start.row, config), left = padding + range.start.column * config.characterWidth; + if (extraStyle = extraStyle || "", this.session.$bidiHandler.isBidiRow(range.start.row)) { + var range1 = range.clone(); + range1.end.row = range1.start.row, range1.end.column = this.session.getLine(range1.start.row).length, this.drawBidiSingleLineMarker(stringBuilder, range1, clazz + " ace_br1 ace_start", config, null, extraStyle); + } else this.elt(clazz + " ace_br1 ace_start", "height:" + height + "px;right:0;top:" + top + "px;left:" + left + "px;" + (extraStyle || "")); + if (this.session.$bidiHandler.isBidiRow(range.end.row)) { + var range1 = range.clone(); + range1.start.row = range1.end.row, range1.start.column = 0, this.drawBidiSingleLineMarker(stringBuilder, range1, clazz + " ace_br12", config, null, extraStyle); + } else { + top = this.$getTop(range.end.row, config); + var width = range.end.column * config.characterWidth; + this.elt(clazz + " ace_br12", "height:" + height + "px;width:" + width + "px;top:" + top + "px;left:" + padding + "px;" + (extraStyle || "")); + } + if (!((height = (range.end.row - range.start.row - 1) * config.lineHeight) <= 0)) { + top = this.$getTop(range.start.row + 1, config); + var radiusClass = (range.start.column ? 1 : 0) | (range.end.column ? 0 : 8); + this.elt(clazz + (radiusClass ? " ace_br" + radiusClass : ""), "height:" + height + "px;right:0;top:" + top + "px;left:" + padding + "px;" + (extraStyle || "")); + } + }, this.drawSingleLineMarker = function(stringBuilder, range, clazz, config, extraLength, extraStyle) { + if (this.session.$bidiHandler.isBidiRow(range.start.row)) return this.drawBidiSingleLineMarker(stringBuilder, range, clazz, config, extraLength, extraStyle); + var height = config.lineHeight, width = (range.end.column + (extraLength || 0) - range.start.column) * config.characterWidth, top = this.$getTop(range.start.row, config), left = this.$padding + range.start.column * config.characterWidth; + this.elt(clazz, "height:" + height + "px;width:" + width + "px;top:" + top + "px;left:" + left + "px;" + (extraStyle || "")); + }, this.drawBidiSingleLineMarker = function(stringBuilder, range, clazz, config, extraLength, extraStyle) { + var height = config.lineHeight, top = this.$getTop(range.start.row, config), padding = this.$padding; + this.session.$bidiHandler.getSelections(range.start.column, range.end.column).forEach(function(selection) { + this.elt(clazz, "height:" + height + "px;width:" + selection.width + (extraLength || 0) + "px;top:" + top + "px;left:" + (padding + selection.left) + "px;" + (extraStyle || "")); + }, this); + }, this.drawFullLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var top = this.$getTop(range.start.row, config), height = config.lineHeight; + range.start.row != range.end.row && (height += this.$getTop(range.end.row, config) - top), this.elt(clazz, "height:" + height + "px;top:" + top + "px;left:0;right:0;" + (extraStyle || "")); + }, this.drawScreenLineMarker = function(stringBuilder, range, clazz, config, extraStyle) { + var top = this.$getTop(range.start.row, config), height = config.lineHeight; + this.elt(clazz, "height:" + height + "px;top:" + top + "px;left:0;right:0;" + (extraStyle || "")); + }; + }).call(Marker.prototype), exports.Marker = Marker; + }), ace.define("ace/layer/text", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/dom", + "ace/lib/lang", + "ace/layer/lines", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "use strict"; + var oop = require("../lib/oop"), dom = require("../lib/dom"), lang = require("../lib/lang"), Lines = require("./lines").Lines, EventEmitter = require("../lib/event_emitter").EventEmitter, Text = function(parentEl) { + this.dom = dom, this.element = this.dom.createElement("div"), this.element.className = "ace_layer ace_text-layer", parentEl.appendChild(this.element), this.$updateEolChar = this.$updateEolChar.bind(this), this.$lines = new Lines(this.element); + }; + (function() { + oop.implement(this, EventEmitter), this.EOF_CHAR = "\xB6", this.EOL_CHAR_LF = "\xAC", this.EOL_CHAR_CRLF = "\xa4", this.EOL_CHAR = this.EOL_CHAR_LF, this.TAB_CHAR = "\u2014", this.SPACE_CHAR = "\xB7", this.$padding = 0, this.MAX_LINE_LENGTH = 10000, this.$updateEolChar = function() { + var doc = this.session.doc, EOL_CHAR = "\n" == doc.getNewLineCharacter() && "windows" != doc.getNewLineMode() ? this.EOL_CHAR_LF : this.EOL_CHAR_CRLF; + if (this.EOL_CHAR != EOL_CHAR) return this.EOL_CHAR = EOL_CHAR, !0; + }, this.setPadding = function(padding) { + this.$padding = padding, this.element.style.margin = "0 " + padding + "px"; + }, this.getLineHeight = function() { + return this.$fontMetrics.$characterSize.height || 0; + }, this.getCharacterWidth = function() { + return this.$fontMetrics.$characterSize.width || 0; + }, this.$setFontMetrics = function(measure) { + this.$fontMetrics = measure, this.$fontMetrics.on("changeCharacterSize", (function(e) { + this._signal("changeCharacterSize", e); + }).bind(this)), this.$pollSizeChanges(); + }, this.checkForSizeChanges = function() { + this.$fontMetrics.checkForSizeChanges(); + }, this.$pollSizeChanges = function() { + return this.$pollSizeChangesTimer = this.$fontMetrics.$pollSizeChanges(); + }, this.setSession = function(session) { + this.session = session, session && this.$computeTabString(); + }, this.showInvisibles = !1, this.showSpaces = !1, this.showTabs = !1, this.showEOL = !1, this.setShowInvisibles = function(showInvisibles) { + return this.showInvisibles != showInvisibles && (this.showInvisibles = showInvisibles, "string" == typeof showInvisibles ? (this.showSpaces = /tab/i.test(showInvisibles), this.showTabs = /space/i.test(showInvisibles), this.showEOL = /eol/i.test(showInvisibles)) : this.showSpaces = this.showTabs = this.showEOL = showInvisibles, this.$computeTabString(), !0); + }, this.displayIndentGuides = !0, this.setDisplayIndentGuides = function(display) { + return this.displayIndentGuides != display && (this.displayIndentGuides = display, this.$computeTabString(), !0); + }, this.$tabStrings = [], this.onChangeTabSize = this.$computeTabString = function() { + var tabSize = this.session.getTabSize(); + this.tabSize = tabSize; + for(var tabStr = this.$tabStrings = [ + 0 + ], i = 1; i < tabSize + 1; i++)if (this.showTabs) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_tab", span.textContent = lang.stringRepeat(this.TAB_CHAR, i), tabStr.push(span); + } else tabStr.push(this.dom.createTextNode(lang.stringRepeat(" ", i), this.element)); + if (this.displayIndentGuides) { + this.$indentGuideRe = /\s\S| \t|\t |\s$/; + var className = "ace_indent-guide", spaceClass = this.showSpaces ? " ace_invisible ace_invisible_space" : "", spaceContent = this.showSpaces ? lang.stringRepeat(this.SPACE_CHAR, this.tabSize) : lang.stringRepeat(" ", this.tabSize), tabClass = this.showTabs ? " ace_invisible ace_invisible_tab" : "", tabContent = this.showTabs ? lang.stringRepeat(this.TAB_CHAR, this.tabSize) : spaceContent, span = this.dom.createElement("span"); + span.className = className + spaceClass, span.textContent = spaceContent, this.$tabStrings[" "] = span; + var span = this.dom.createElement("span"); + span.className = className + tabClass, span.textContent = tabContent, this.$tabStrings["\t"] = span; + } + }, this.updateLines = function(config, firstRow, lastRow) { + if (this.config.lastRow != config.lastRow || this.config.firstRow != config.firstRow) return this.update(config); + this.config = config; + for(var first = Math.max(firstRow, config.firstRow), last = Math.min(lastRow, config.lastRow), lineElements = this.element.childNodes, lineElementsIdx = 0, row = config.firstRow; row < first; row++){ + var foldLine = this.session.getFoldLine(row); + if (foldLine) { + if (foldLine.containsRow(first)) { + first = foldLine.start.row; + break; + } + row = foldLine.end.row; + } + lineElementsIdx++; + } + for(var heightChanged = !1, row = first, foldLine = this.session.getNextFoldLine(row), foldStart = foldLine ? foldLine.start.row : 1 / 0; row > foldStart && (row = foldLine.end.row + 1, foldStart = (foldLine = this.session.getNextFoldLine(row, foldLine)) ? foldLine.start.row : 1 / 0), !(row > last);){ + var lineElement = lineElements[lineElementsIdx++]; + if (lineElement) { + this.dom.removeChildren(lineElement), this.$renderLine(lineElement, row, row == foldStart && foldLine), heightChanged && (lineElement.style.top = this.$lines.computeLineTop(row, config, this.session) + "px"); + var height = config.lineHeight * this.session.getRowLength(row) + "px"; + lineElement.style.height != height && (heightChanged = !0, lineElement.style.height = height); + } + row++; + } + if (heightChanged) for(; lineElementsIdx < this.$lines.cells.length;){ + var cell = this.$lines.cells[lineElementsIdx++]; + cell.element.style.top = this.$lines.computeLineTop(cell.row, config, this.session) + "px"; + } + }, this.scrollLines = function(config) { + var oldConfig = this.config; + if (this.config = config, this.$lines.pageChanged(oldConfig, config)) return this.update(config); + this.$lines.moveContainer(config); + var lastRow = config.lastRow, oldLastRow = oldConfig ? oldConfig.lastRow : -1; + if (!oldConfig || oldLastRow < config.firstRow) return this.update(config); + if (lastRow < oldConfig.firstRow) return this.update(config); + if (!oldConfig || oldConfig.lastRow < config.firstRow) return this.update(config); + if (config.lastRow < oldConfig.firstRow) return this.update(config); + if (oldConfig.firstRow < config.firstRow) for(var row = this.session.getFoldedRowCount(oldConfig.firstRow, config.firstRow - 1); row > 0; row--)this.$lines.shift(); + if (oldConfig.lastRow > config.lastRow) for(var row = this.session.getFoldedRowCount(config.lastRow + 1, oldConfig.lastRow); row > 0; row--)this.$lines.pop(); + config.firstRow < oldConfig.firstRow && this.$lines.unshift(this.$renderLinesFragment(config, config.firstRow, oldConfig.firstRow - 1)), config.lastRow > oldConfig.lastRow && this.$lines.push(this.$renderLinesFragment(config, oldConfig.lastRow + 1, config.lastRow)); + }, this.$renderLinesFragment = function(config, firstRow, lastRow) { + for(var fragment = [], row = firstRow, foldLine = this.session.getNextFoldLine(row), foldStart = foldLine ? foldLine.start.row : 1 / 0; row > foldStart && (row = foldLine.end.row + 1, foldStart = (foldLine = this.session.getNextFoldLine(row, foldLine)) ? foldLine.start.row : 1 / 0), !(row > lastRow);){ + var line = this.$lines.createCell(row, config, this.session), lineEl = line.element; + this.dom.removeChildren(lineEl), dom.setStyle(lineEl.style, "height", this.$lines.computeLineHeight(row, config, this.session) + "px"), dom.setStyle(lineEl.style, "top", this.$lines.computeLineTop(row, config, this.session) + "px"), this.$renderLine(lineEl, row, row == foldStart && foldLine), this.$useLineGroups() ? lineEl.className = "ace_line_group" : lineEl.className = "ace_line", fragment.push(line), row++; + } + return fragment; + }, this.update = function(config) { + this.$lines.moveContainer(config), this.config = config; + for(var firstRow = config.firstRow, lastRow = config.lastRow, lines = this.$lines; lines.getLength();)lines.pop(); + lines.push(this.$renderLinesFragment(config, firstRow, lastRow)); + }, this.$textToken = { + text: !0, + rparen: !0, + lparen: !0 + }, this.$renderToken = function(parent, screenColumn, token, value) { + for(var m, self = this, re = /(\t)|( +)|([\x00-\x1f\x80-\xa0\xad\u1680\u180E\u2000-\u200f\u2028\u2029\u202F\u205F\uFEFF\uFFF9-\uFFFC]+)|(\u3000)|([\u1100-\u115F\u11A3-\u11A7\u11FA-\u11FF\u2329-\u232A\u2E80-\u2E99\u2E9B-\u2EF3\u2F00-\u2FD5\u2FF0-\u2FFB\u3001-\u303E\u3041-\u3096\u3099-\u30FF\u3105-\u312D\u3131-\u318E\u3190-\u31BA\u31C0-\u31E3\u31F0-\u321E\u3220-\u3247\u3250-\u32FE\u3300-\u4DBF\u4E00-\uA48C\uA490-\uA4C6\uA960-\uA97C\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFAFF\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE66\uFE68-\uFE6B\uFF01-\uFF60\uFFE0-\uFFE6]|[\uD800-\uDBFF][\uDC00-\uDFFF])/g, valueFragment = this.dom.createFragment(this.element), i = 0; m = re.exec(value);){ + var tab = m[1], simpleSpace = m[2], controlCharacter = m[3], cjkSpace = m[4], cjk = m[5]; + if (self.showSpaces || !simpleSpace) { + var before = i != m.index ? value.slice(i, m.index) : ""; + if (i = m.index + m[0].length, before && valueFragment.appendChild(this.dom.createTextNode(before, this.element)), tab) { + var tabSize = self.session.getScreenTabSize(screenColumn + m.index); + valueFragment.appendChild(self.$tabStrings[tabSize].cloneNode(!0)), screenColumn += tabSize - 1; + } else if (simpleSpace) if (self.showSpaces) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_space", span.textContent = lang.stringRepeat(self.SPACE_CHAR, simpleSpace.length), valueFragment.appendChild(span); + } else valueFragment.appendChild(this.com.createTextNode(simpleSpace, this.element)); + else if (controlCharacter) { + var span = this.dom.createElement("span"); + span.className = "ace_invisible ace_invisible_space ace_invalid", span.textContent = lang.stringRepeat(self.SPACE_CHAR, controlCharacter.length), valueFragment.appendChild(span); + } else if (cjkSpace) { + screenColumn += 1; + var span = this.dom.createElement("span"); + span.style.width = 2 * self.config.characterWidth + "px", span.className = self.showSpaces ? "ace_cjk ace_invisible ace_invisible_space" : "ace_cjk", span.textContent = self.showSpaces ? self.SPACE_CHAR : cjkSpace, valueFragment.appendChild(span); + } else if (cjk) { + screenColumn += 1; + var span = this.dom.createElement("span"); + span.style.width = 2 * self.config.characterWidth + "px", span.className = "ace_cjk", span.textContent = cjk, valueFragment.appendChild(span); + } + } + } + if (valueFragment.appendChild(this.dom.createTextNode(i ? value.slice(i) : value, this.element)), this.$textToken[token.type]) parent.appendChild(valueFragment); + else { + var classes = "ace_" + token.type.replace(/\./g, " ace_"), span = this.dom.createElement("span"); + "fold" == token.type && (span.style.width = token.value.length * this.config.characterWidth + "px"), span.className = classes, span.appendChild(valueFragment), parent.appendChild(span); + } + return screenColumn + value.length; + }, this.renderIndentGuide = function(parent, value, max) { + var cols = value.search(this.$indentGuideRe); + if (cols <= 0 || cols >= max) return value; + if (" " == value[0]) { + for(var count = (cols -= cols % this.tabSize) / this.tabSize, i = 0; i < count; i++)parent.appendChild(this.$tabStrings[" "].cloneNode(!0)); + return value.substr(cols); + } + if ("\t" == value[0]) { + for(var i = 0; i < cols; i++)parent.appendChild(this.$tabStrings["\t"].cloneNode(!0)); + return value.substr(cols); + } + return value; + }, this.$createLineElement = function(parent) { + var lineEl = this.dom.createElement("div"); + return lineEl.className = "ace_line", lineEl.style.height = this.config.lineHeight + "px", lineEl; + }, this.$renderWrappedLine = function(parent, tokens, splits) { + var chars = 0, split = 0, splitChars = splits[0], screenColumn = 0, lineEl = this.$createLineElement(); + parent.appendChild(lineEl); + for(var i = 0; i < tokens.length; i++){ + var token = tokens[i], value = token.value; + if (0 == i && this.displayIndentGuides) { + if (chars = value.length, !(value = this.renderIndentGuide(lineEl, value, splitChars))) continue; + chars -= value.length; + } + if (chars + value.length < splitChars) screenColumn = this.$renderToken(lineEl, screenColumn, token, value), chars += value.length; + else { + for(; chars + value.length >= splitChars;)screenColumn = this.$renderToken(lineEl, screenColumn, token, value.substring(0, splitChars - chars)), value = value.substring(splitChars - chars), chars = splitChars, lineEl = this.$createLineElement(), parent.appendChild(lineEl), lineEl.appendChild(this.dom.createTextNode(lang.stringRepeat("\xa0", splits.indent), this.element)), split++, screenColumn = 0, splitChars = splits[split] || Number.MAX_VALUE; + 0 != value.length && (chars += value.length, screenColumn = this.$renderToken(lineEl, screenColumn, token, value)); + } + } + splits[splits.length - 1] > this.MAX_LINE_LENGTH && this.$renderOverflowMessage(lineEl, screenColumn, null, "", !0); + }, this.$renderSimpleLine = function(parent, tokens) { + var screenColumn = 0, token = tokens[0], value = token.value; + this.displayIndentGuides && (value = this.renderIndentGuide(parent, value)), value && (screenColumn = this.$renderToken(parent, screenColumn, token, value)); + for(var i = 1; i < tokens.length; i++){ + if (screenColumn + (value = (token = tokens[i]).value).length > this.MAX_LINE_LENGTH) return this.$renderOverflowMessage(parent, screenColumn, token, value); + screenColumn = this.$renderToken(parent, screenColumn, token, value); + } + }, this.$renderOverflowMessage = function(parent, screenColumn, token, value, hide) { + token && this.$renderToken(parent, screenColumn, token, value.slice(0, this.MAX_LINE_LENGTH - screenColumn)); + var overflowEl = this.dom.createElement("span"); + overflowEl.className = "ace_inline_button ace_keyword ace_toggle_wrap", overflowEl.textContent = hide ? "" : "", parent.appendChild(overflowEl); + }, this.$renderLine = function(parent, row, foldLine) { + if (foldLine || !1 == foldLine || (foldLine = this.session.getFoldLine(row)), foldLine) var tokens = this.$getFoldLineTokens(row, foldLine); + else var tokens = this.session.getTokens(row); + var lastLineEl = parent; + if (tokens.length) { + var splits = this.session.getRowSplitData(row); + if (splits && splits.length) { + this.$renderWrappedLine(parent, tokens, splits); + var lastLineEl = parent.lastChild; + } else { + var lastLineEl = parent; + this.$useLineGroups() && (lastLineEl = this.$createLineElement(), parent.appendChild(lastLineEl)), this.$renderSimpleLine(lastLineEl, tokens); + } + } else this.$useLineGroups() && (lastLineEl = this.$createLineElement(), parent.appendChild(lastLineEl)); + if (this.showEOL && lastLineEl) { + foldLine && (row = foldLine.end.row); + var invisibleEl = this.dom.createElement("span"); + invisibleEl.className = "ace_invisible ace_invisible_eol", invisibleEl.textContent = row == this.session.getLength() - 1 ? this.EOF_CHAR : this.EOL_CHAR, lastLineEl.appendChild(invisibleEl); + } + }, this.$getFoldLineTokens = function(row2, foldLine) { + var session = this.session, renderTokens = [], tokens1 = session.getTokens(row2); + return foldLine.walk(function(placeholder, row, column, lastColumn, isNewRow) { + null != placeholder ? renderTokens.push({ + type: "fold", + value: placeholder + }) : (isNewRow && (tokens1 = session.getTokens(row)), tokens1.length && function(tokens, from, to) { + for(var idx = 0, col = 0; col + tokens[idx].value.length < from;)if (col += tokens[idx].value.length, idx++, idx == tokens.length) return; + if (col != from) { + var value = tokens[idx].value.substring(from - col); + value.length > to - from && (value = value.substring(0, to - from)), renderTokens.push({ + type: tokens[idx].type, + value: value + }), col = from + value.length, idx += 1; + } + for(; col < to && idx < tokens.length;){ + var value = tokens[idx].value; + value.length + col > to ? renderTokens.push({ + type: tokens[idx].type, + value: value.substring(0, to - col) + }) : renderTokens.push(tokens[idx]), col += value.length, idx += 1; + } + }(tokens1, lastColumn, column)); + }, foldLine.end.row, this.session.getLine(foldLine.end.row).length), renderTokens; + }, this.$useLineGroups = function() { + return this.session.getUseWrapMode(); + }, this.destroy = function() {}; + }).call(Text.prototype), exports.Text = Text; + }), ace.define("ace/layer/cursor", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var dom = require("../lib/dom"), Cursor = function(parentEl) { + this.element = dom.createElement("div"), this.element.className = "ace_layer ace_cursor-layer", parentEl.appendChild(this.element), this.isVisible = !1, this.isBlinking = !0, this.blinkInterval = 1000, this.smoothBlinking = !1, this.cursors = [], this.cursor = this.addCursor(), dom.addCssClass(this.element, "ace_hidden-cursors"), this.$updateCursors = this.$updateOpacity.bind(this); + }; + (function() { + this.$updateOpacity = function(val) { + for(var cursors = this.cursors, i = cursors.length; i--;)dom.setStyle(cursors[i].style, "opacity", val ? "" : "0"); + }, this.$startCssAnimation = function() { + for(var cursors = this.cursors, i = cursors.length; i--;)cursors[i].style.animationDuration = this.blinkInterval + "ms"; + this.$isAnimating = !0, setTimeout((function() { + this.$isAnimating && dom.addCssClass(this.element, "ace_animate-blinking"); + }).bind(this)); + }, this.$stopCssAnimation = function() { + this.$isAnimating = !1, dom.removeCssClass(this.element, "ace_animate-blinking"); + }, this.$padding = 0, this.setPadding = function(padding) { + this.$padding = padding; + }, this.setSession = function(session) { + this.session = session; + }, this.setBlinking = function(blinking) { + blinking != this.isBlinking && (this.isBlinking = blinking, this.restartTimer()); + }, this.setBlinkInterval = function(blinkInterval) { + blinkInterval != this.blinkInterval && (this.blinkInterval = blinkInterval, this.restartTimer()); + }, this.setSmoothBlinking = function(smoothBlinking) { + smoothBlinking != this.smoothBlinking && (this.smoothBlinking = smoothBlinking, dom.setCssClass(this.element, "ace_smooth-blinking", smoothBlinking), this.$updateCursors(!0), this.restartTimer()); + }, this.addCursor = function() { + var el = dom.createElement("div"); + return el.className = "ace_cursor", this.element.appendChild(el), this.cursors.push(el), el; + }, this.removeCursor = function() { + if (this.cursors.length > 1) { + var el = this.cursors.pop(); + return el.parentNode.removeChild(el), el; + } + }, this.hideCursor = function() { + this.isVisible = !1, dom.addCssClass(this.element, "ace_hidden-cursors"), this.restartTimer(); + }, this.showCursor = function() { + this.isVisible = !0, dom.removeCssClass(this.element, "ace_hidden-cursors"), this.restartTimer(); + }, this.restartTimer = function() { + var update = this.$updateCursors; + if (clearInterval(this.intervalId), clearTimeout(this.timeoutId), this.$stopCssAnimation(), this.smoothBlinking && (this.$isSmoothBlinking = !1, dom.removeCssClass(this.element, "ace_smooth-blinking")), update(!0), !this.isBlinking || !this.blinkInterval || !this.isVisible) { + this.$stopCssAnimation(); + return; + } + if (this.smoothBlinking && (this.$isSmoothBlinking = !0, setTimeout((function() { + this.$isSmoothBlinking && dom.addCssClass(this.element, "ace_smooth-blinking"); + }).bind(this))), dom.HAS_CSS_ANIMATION) this.$startCssAnimation(); + else { + var blink = (function() { + this.timeoutId = setTimeout(function() { + update(!1); + }, 0.6 * this.blinkInterval); + }).bind(this); + this.intervalId = setInterval(function() { + update(!0), blink(); + }, this.blinkInterval), blink(); + } + }, this.getPixelPosition = function(position, onScreen) { + if (!this.config || !this.session) return { + left: 0, + top: 0 + }; + position || (position = this.session.selection.getCursor()); + var pos = this.session.documentToScreenPosition(position), cursorLeft = this.$padding + (this.session.$bidiHandler.isBidiRow(pos.row, position.row) ? this.session.$bidiHandler.getPosLeft(pos.column) : pos.column * this.config.characterWidth), cursorTop = (pos.row - (onScreen ? this.config.firstRowScreen : 0)) * this.config.lineHeight; + return { + left: cursorLeft, + top: cursorTop + }; + }, this.isCursorInView = function(pixelPos, config) { + return pixelPos.top >= 0 && pixelPos.top < config.maxHeight; + }, this.update = function(config) { + this.config = config; + var selections = this.session.$selectionMarkers, i = 0, cursorIndex = 0; + (void 0 === selections || 0 === selections.length) && (selections = [ + { + cursor: null + } + ]); + for(var i = 0, n = selections.length; i < n; i++){ + var pixelPos = this.getPixelPosition(selections[i].cursor, !0); + if (!(pixelPos.top > config.height + config.offset) && !(pixelPos.top < 0) || !(i > 1)) { + var element = this.cursors[cursorIndex++] || this.addCursor(), style = element.style; + this.drawCursor ? this.drawCursor(element, pixelPos, config, selections[i], this.session) : this.isCursorInView(pixelPos, config) ? (dom.setStyle(style, "display", "block"), dom.translate(element, pixelPos.left, pixelPos.top), dom.setStyle(style, "width", Math.round(config.characterWidth) + "px"), dom.setStyle(style, "height", config.lineHeight + "px")) : dom.setStyle(style, "display", "none"); + } + } + for(; this.cursors.length > cursorIndex;)this.removeCursor(); + var overwrite = this.session.getOverwrite(); + this.$setOverwrite(overwrite), this.$pixelPos = pixelPos, this.restartTimer(); + }, this.drawCursor = null, this.$setOverwrite = function(overwrite) { + overwrite != this.overwrite && (this.overwrite = overwrite, overwrite ? dom.addCssClass(this.element, "ace_overwrite-cursors") : dom.removeCssClass(this.element, "ace_overwrite-cursors")); + }, this.destroy = function() { + clearInterval(this.intervalId), clearTimeout(this.timeoutId); + }; + }).call(Cursor.prototype), exports.Cursor = Cursor; + }), ace.define("ace/scrollbar", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/dom", + "ace/lib/event", + "ace/lib/event_emitter" + ], function(require, exports, module) { + "use strict"; + var oop = require("./lib/oop"), dom = require("./lib/dom"), event = require("./lib/event"), EventEmitter = require("./lib/event_emitter").EventEmitter, ScrollBar = function(parent) { + this.element = dom.createElement("div"), this.element.className = "ace_scrollbar ace_scrollbar" + this.classSuffix, this.inner = dom.createElement("div"), this.inner.className = "ace_scrollbar-inner", this.inner.textContent = "\xa0", this.element.appendChild(this.inner), parent.appendChild(this.element), this.setVisible(!1), this.skipEvent = !1, event.addListener(this.element, "scroll", this.onScroll.bind(this)), event.addListener(this.element, "mousedown", event.preventDefault); + }; + (function() { + oop.implement(this, EventEmitter), this.setVisible = function(isVisible) { + this.element.style.display = isVisible ? "" : "none", this.isVisible = isVisible, this.coeff = 1; + }; + }).call(ScrollBar.prototype); + var VScrollBar = function(parent, renderer) { + ScrollBar.call(this, parent), this.scrollTop = 0, this.scrollHeight = 0, renderer.$scrollbarWidth = this.width = dom.scrollbarWidth(parent.ownerDocument), this.inner.style.width = this.element.style.width = (this.width || 15) + 5 + "px", this.$minWidth = 0; + }; + oop.inherits(VScrollBar, ScrollBar), (function() { + this.classSuffix = '-v', this.onScroll = function() { + if (!this.skipEvent) { + if (this.scrollTop = this.element.scrollTop, 1 != this.coeff) { + var h = this.element.clientHeight / this.scrollHeight; + this.scrollTop = this.scrollTop * (1 - h) / (this.coeff - h); + } + this._emit("scroll", { + data: this.scrollTop + }); + } + this.skipEvent = !1; + }, this.getWidth = function() { + return Math.max(this.isVisible ? this.width : 0, this.$minWidth || 0); + }, this.setHeight = function(height) { + this.element.style.height = height + "px"; + }, this.setInnerHeight = this.setScrollHeight = function(height) { + this.scrollHeight = height, height > 32768 ? (this.coeff = 32768 / height, height = 32768) : 1 != this.coeff && (this.coeff = 1), this.inner.style.height = height + "px"; + }, this.setScrollTop = function(scrollTop) { + this.scrollTop != scrollTop && (this.skipEvent = !0, this.scrollTop = scrollTop, this.element.scrollTop = scrollTop * this.coeff); + }; + }).call(VScrollBar.prototype); + var HScrollBar = function(parent, renderer) { + ScrollBar.call(this, parent), this.scrollLeft = 0, this.height = renderer.$scrollbarWidth, this.inner.style.height = this.element.style.height = (this.height || 15) + 5 + "px"; + }; + oop.inherits(HScrollBar, ScrollBar), (function() { + this.classSuffix = '-h', this.onScroll = function() { + this.skipEvent || (this.scrollLeft = this.element.scrollLeft, this._emit("scroll", { + data: this.scrollLeft + })), this.skipEvent = !1; + }, this.getHeight = function() { + return this.isVisible ? this.height : 0; + }, this.setWidth = function(width) { + this.element.style.width = width + "px"; + }, this.setInnerWidth = function(width) { + this.inner.style.width = width + "px"; + }, this.setScrollWidth = function(width) { + this.inner.style.width = width + "px"; + }, this.setScrollLeft = function(scrollLeft) { + this.scrollLeft != scrollLeft && (this.skipEvent = !0, this.scrollLeft = this.element.scrollLeft = scrollLeft); + }; + }).call(HScrollBar.prototype), exports.ScrollBar = VScrollBar, exports.ScrollBarV = VScrollBar, exports.ScrollBarH = HScrollBar, exports.VScrollBar = VScrollBar, exports.HScrollBar = HScrollBar; + }), ace.define("ace/renderloop", [ + "require", + "exports", + "module", + "ace/lib/event" + ], function(require, exports, module) { + "use strict"; + var event = require("./lib/event"), RenderLoop = function(onRender, win) { + this.onRender = onRender, this.pending = !1, this.changes = 0, this.$recursionLimit = 2, this.window = win || window; + var _self = this; + this._flush = function(ts) { + _self.pending = !1; + var changes = _self.changes; + if (changes && (event.blockIdle(100), _self.changes = 0, _self.onRender(changes)), _self.changes) { + if (_self.$recursionLimit-- < 0) return; + _self.schedule(); + } else _self.$recursionLimit = 2; + }; + }; + (function() { + this.schedule = function(change) { + this.changes = this.changes | change, this.changes && !this.pending && (event.nextFrame(this._flush), this.pending = !0); + }, this.clear = function(change) { + var changes = this.changes; + return this.changes = 0, changes; + }; + }).call(RenderLoop.prototype), exports.RenderLoop = RenderLoop; + }), ace.define("ace/layer/font_metrics", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/dom", + "ace/lib/lang", + "ace/lib/event", + "ace/lib/useragent", + "ace/lib/event_emitter" + ], function(require, exports, module) { + var oop = require("../lib/oop"), dom = require("../lib/dom"), lang = require("../lib/lang"), event = require("../lib/event"), useragent = require("../lib/useragent"), EventEmitter = require("../lib/event_emitter").EventEmitter, USE_OBSERVER = "function" == typeof ResizeObserver, FontMetrics = exports.FontMetrics = function(parentEl) { + this.el = dom.createElement("div"), this.$setMeasureNodeStyles(this.el.style, !0), this.$main = dom.createElement("div"), this.$setMeasureNodeStyles(this.$main.style), this.$measureNode = dom.createElement("div"), this.$setMeasureNodeStyles(this.$measureNode.style), this.el.appendChild(this.$main), this.el.appendChild(this.$measureNode), parentEl.appendChild(this.el), this.$measureNode.textContent = lang.stringRepeat("X", 256), this.$characterSize = { + width: 0, + height: 0 + }, USE_OBSERVER ? this.$addObserver() : this.checkForSizeChanges(); + }; + (function() { + oop.implement(this, EventEmitter), this.$characterSize = { + width: 0, + height: 0 + }, this.$setMeasureNodeStyles = function(style, isRoot) { + style.width = style.height = "auto", style.left = style.top = "0px", style.visibility = "hidden", style.position = "absolute", style.whiteSpace = "pre", useragent.isIE < 8 ? style["font-family"] = "inherit" : style.font = "inherit", style.overflow = isRoot ? "hidden" : "visible"; + }, this.checkForSizeChanges = function(size) { + if (void 0 === size && (size = this.$measureSizes()), size && (this.$characterSize.width !== size.width || this.$characterSize.height !== size.height)) { + this.$measureNode.style.fontWeight = "bold"; + var boldSize = this.$measureSizes(); + this.$measureNode.style.fontWeight = "", this.$characterSize = size, this.charSizes = Object.create(null), this.allowBoldFonts = boldSize && boldSize.width === size.width && boldSize.height === size.height, this._emit("changeCharacterSize", { + data: size + }); + } + }, this.$addObserver = function() { + var self = this; + this.$observer = new window.ResizeObserver(function(e) { + self.checkForSizeChanges(); + }), this.$observer.observe(this.$measureNode); + }, this.$pollSizeChanges = function() { + if (this.$pollSizeChangesTimer || this.$observer) return this.$pollSizeChangesTimer; + var self = this; + return this.$pollSizeChangesTimer = event.onIdle(function cb() { + self.checkForSizeChanges(), event.onIdle(cb, 500); + }, 500); + }, this.setPolling = function(val) { + val ? this.$pollSizeChanges() : this.$pollSizeChangesTimer && (clearInterval(this.$pollSizeChangesTimer), this.$pollSizeChangesTimer = 0); + }, this.$measureSizes = function(node) { + var size = { + height: (node || this.$measureNode).clientHeight, + width: (node || this.$measureNode).clientWidth / 256 + }; + return 0 === size.width || 0 === size.height ? null : size; + }, this.$measureCharWidth = function(ch) { + return this.$main.textContent = lang.stringRepeat(ch, 256), this.$main.getBoundingClientRect().width / 256; + }, this.getCharacterWidth = function(ch) { + var w = this.charSizes[ch]; + return void 0 === w && (w = this.charSizes[ch] = this.$measureCharWidth(ch) / this.$characterSize.width), w; + }, this.destroy = function() { + clearInterval(this.$pollSizeChangesTimer), this.$observer && this.$observer.disconnect(), this.el && this.el.parentNode && this.el.parentNode.removeChild(this.el); + }, this.$getZoom = function getZoom(element) { + return element && element.parentElement ? (window.getComputedStyle(element).zoom || 1) * getZoom(element.parentElement) : 1; + }, this.$initTransformMeasureNodes = function() { + var t1 = function(t, l) { + return [ + "div", + { + style: "position: absolute;top:" + t + "px;left:" + l + "px;" + } + ]; + }; + this.els = dom.buildDom([ + t1(0, 0), + t1(200, 0), + t1(0, 200), + t1(200, 200) + ], this.el); + }, this.transformCoordinates = function(clientPos, elPos) { + function solve(l1, l2, r) { + var det = l1[1] * l2[0] - l1[0] * l2[1]; + return [ + (-l2[1] * r[0] + l2[0] * r[1]) / det, + (+l1[1] * r[0] - l1[0] * r[1]) / det + ]; + } + function sub(a, b) { + return [ + a[0] - b[0], + a[1] - b[1] + ]; + } + function add(a, b) { + return [ + a[0] + b[0], + a[1] + b[1] + ]; + } + function mul(a, b) { + return [ + a * b[0], + a * b[1] + ]; + } + function p(el) { + var r = el.getBoundingClientRect(); + return [ + r.left, + r.top + ]; + } + clientPos && (clientPos = mul(1 / this.$getZoom(this.el), clientPos)), this.els || this.$initTransformMeasureNodes(); + var a1 = p(this.els[0]), b1 = p(this.els[1]), c = p(this.els[2]), d = p(this.els[3]), h = solve(sub(d, b1), sub(d, c), sub(add(b1, c), add(d, a1))), m1 = mul(1 + h[0], sub(b1, a1)), m2 = mul(1 + h[1], sub(c, a1)); + if (elPos) { + var x = elPos, k = h[0] * x[0] / 200 + h[1] * x[1] / 200 + 1, ut = add(mul(x[0], m1), mul(x[1], m2)); + return add(mul(1 / k / 200, ut), a1); + } + var u = sub(clientPos, a1), f = solve(sub(m1, mul(h[0], u)), sub(m2, mul(h[1], u)), u); + return mul(200, f); + }; + }).call(FontMetrics.prototype); + }), ace.define("ace/virtual_renderer", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/dom", + "ace/config", + "ace/layer/gutter", + "ace/layer/marker", + "ace/layer/text", + "ace/layer/cursor", + "ace/scrollbar", + "ace/scrollbar", + "ace/renderloop", + "ace/layer/font_metrics", + "ace/lib/event_emitter", + "ace/lib/useragent" + ], function(require, exports, module8) { + "use strict"; + var oop = require("./lib/oop"), dom = require("./lib/dom"), config2 = require("./config"), GutterLayer = require("./layer/gutter").Gutter, MarkerLayer = require("./layer/marker").Marker, TextLayer = require("./layer/text").Text, CursorLayer = require("./layer/cursor").Cursor, HScrollBar = require("./scrollbar").HScrollBar, VScrollBar = require("./scrollbar").VScrollBar, RenderLoop = require("./renderloop").RenderLoop, FontMetrics = require("./layer/font_metrics").FontMetrics, EventEmitter = require("./lib/event_emitter").EventEmitter, editorCss = "\ +.ace_br1 {border-top-left-radius : 3px;}\ +.ace_br2 {border-top-right-radius : 3px;}\ +.ace_br3 {border-top-left-radius : 3px; border-top-right-radius: 3px;}\ +.ace_br4 {border-bottom-right-radius: 3px;}\ +.ace_br5 {border-top-left-radius : 3px; border-bottom-right-radius: 3px;}\ +.ace_br6 {border-top-right-radius : 3px; border-bottom-right-radius: 3px;}\ +.ace_br7 {border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px;}\ +.ace_br8 {border-bottom-left-radius : 3px;}\ +.ace_br9 {border-top-left-radius : 3px; border-bottom-left-radius: 3px;}\ +.ace_br10{border-top-right-radius : 3px; border-bottom-left-radius: 3px;}\ +.ace_br11{border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br12{border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br13{border-top-left-radius : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br14{border-top-right-radius : 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_br15{border-top-left-radius : 3px; border-top-right-radius: 3px; border-bottom-right-radius: 3px; border-bottom-left-radius: 3px;}\ +.ace_editor {\ +position: relative;\ +overflow: hidden;\ +padding: 0;\ +font: 12px/normal 'Monaco', 'Menlo', 'Ubuntu Mono', 'Consolas', 'source-code-pro', monospace;\ +direction: ltr;\ +text-align: left;\ +-webkit-tap-highlight-color: rgba(0, 0, 0, 0);\ +}\ +.ace_scroller {\ +position: absolute;\ +overflow: hidden;\ +top: 0;\ +bottom: 0;\ +background-color: inherit;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +cursor: text;\ +}\ +.ace_content {\ +position: absolute;\ +box-sizing: border-box;\ +min-width: 100%;\ +contain: style size layout;\ +font-variant-ligatures: no-common-ligatures;\ +}\ +.ace_dragging .ace_scroller:before{\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +bottom: 0;\ +content: '';\ +background: rgba(250, 250, 250, 0.01);\ +z-index: 1000;\ +}\ +.ace_dragging.ace_dark .ace_scroller:before{\ +background: rgba(0, 0, 0, 0.01);\ +}\ +.ace_selecting, .ace_selecting * {\ +cursor: text !important;\ +}\ +.ace_gutter {\ +position: absolute;\ +overflow : hidden;\ +width: auto;\ +top: 0;\ +bottom: 0;\ +left: 0;\ +cursor: default;\ +z-index: 4;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +contain: style size layout;\ +}\ +.ace_gutter-active-line {\ +position: absolute;\ +left: 0;\ +right: 0;\ +}\ +.ace_scroller.ace_scroll-left {\ +box-shadow: 17px 0 16px -16px rgba(0, 0, 0, 0.4) inset;\ +}\ +.ace_gutter-cell {\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +padding-left: 19px;\ +padding-right: 6px;\ +background-repeat: no-repeat;\ +}\ +.ace_gutter-cell.ace_error {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAABOFBMVEX/////////QRswFAb/Ui4wFAYwFAYwFAaWGAfDRymzOSH/PxswFAb/SiUwFAYwFAbUPRvjQiDllog5HhHdRybsTi3/Tyv9Tir+Syj/UC3////XurebMBIwFAb/RSHbPx/gUzfdwL3kzMivKBAwFAbbvbnhPx66NhowFAYwFAaZJg8wFAaxKBDZurf/RB6mMxb/SCMwFAYwFAbxQB3+RB4wFAb/Qhy4Oh+4QifbNRcwFAYwFAYwFAb/QRzdNhgwFAYwFAbav7v/Uy7oaE68MBK5LxLewr/r2NXewLswFAaxJw4wFAbkPRy2PyYwFAaxKhLm1tMwFAazPiQwFAaUGAb/QBrfOx3bvrv/VC/maE4wFAbRPBq6MRO8Qynew8Dp2tjfwb0wFAbx6eju5+by6uns4uH9/f36+vr/GkHjAAAAYnRSTlMAGt+64rnWu/bo8eAA4InH3+DwoN7j4eLi4xP99Nfg4+b+/u9B/eDs1MD1mO7+4PHg2MXa347g7vDizMLN4eG+Pv7i5evs/v79yu7S3/DV7/498Yv24eH+4ufQ3Ozu/v7+y13sRqwAAADLSURBVHjaZc/XDsFgGIBhtDrshlitmk2IrbHFqL2pvXf/+78DPokj7+Fz9qpU/9UXJIlhmPaTaQ6QPaz0mm+5gwkgovcV6GZzd5JtCQwgsxoHOvJO15kleRLAnMgHFIESUEPmawB9ngmelTtipwwfASilxOLyiV5UVUyVAfbG0cCPHig+GBkzAENHS0AstVF6bacZIOzgLmxsHbt2OecNgJC83JERmePUYq8ARGkJx6XtFsdddBQgZE2nPR6CICZhawjA4Fb/chv+399kfR+MMMDGOQAAAABJRU5ErkJggg==\");\ +background-repeat: no-repeat;\ +background-position: 2px center;\ +}\ +.ace_gutter-cell.ace_warning {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAMAAAAoLQ9TAAAAmVBMVEX///8AAAD///8AAAAAAABPSzb/5sAAAAB/blH/73z/ulkAAAAAAAD85pkAAAAAAAACAgP/vGz/rkDerGbGrV7/pkQICAf////e0IsAAAD/oED/qTvhrnUAAAD/yHD/njcAAADuv2r/nz//oTj/p064oGf/zHAAAAA9Nir/tFIAAAD/tlTiuWf/tkIAAACynXEAAAAAAAAtIRW7zBpBAAAAM3RSTlMAABR1m7RXO8Ln31Z36zT+neXe5OzooRDfn+TZ4p3h2hTf4t3k3ucyrN1K5+Xaks52Sfs9CXgrAAAAjklEQVR42o3PbQ+CIBQFYEwboPhSYgoYunIqqLn6/z8uYdH8Vmdnu9vz4WwXgN/xTPRD2+sgOcZjsge/whXZgUaYYvT8QnuJaUrjrHUQreGczuEafQCO/SJTufTbroWsPgsllVhq3wJEk2jUSzX3CUEDJC84707djRc5MTAQxoLgupWRwW6UB5fS++NV8AbOZgnsC7BpEAAAAABJRU5ErkJggg==\");\ +background-position: 2px center;\ +}\ +.ace_gutter-cell.ace_info {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAAAAAA6mKC9AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAAJ0Uk5TAAB2k804AAAAPklEQVQY02NgIB68QuO3tiLznjAwpKTgNyDbMegwisCHZUETUZV0ZqOquBpXj2rtnpSJT1AEnnRmL2OgGgAAIKkRQap2htgAAAAASUVORK5CYII=\");\ +background-position: 2px center;\ +}\ +.ace_dark .ace_gutter-cell.ace_info {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQBAMAAADt3eJSAAAAJFBMVEUAAAChoaGAgIAqKiq+vr6tra1ZWVmUlJSbm5s8PDxubm56enrdgzg3AAAAAXRSTlMAQObYZgAAAClJREFUeNpjYMAPdsMYHegyJZFQBlsUlMFVCWUYKkAZMxZAGdxlDMQBAG+TBP4B6RyJAAAAAElFTkSuQmCC\");\ +}\ +.ace_scrollbar {\ +contain: strict;\ +position: absolute;\ +right: 0;\ +bottom: 0;\ +z-index: 6;\ +}\ +.ace_scrollbar-inner {\ +position: absolute;\ +cursor: text;\ +left: 0;\ +top: 0;\ +}\ +.ace_scrollbar-v{\ +overflow-x: hidden;\ +overflow-y: scroll;\ +top: 0;\ +}\ +.ace_scrollbar-h {\ +overflow-x: scroll;\ +overflow-y: hidden;\ +left: 0;\ +}\ +.ace_print-margin {\ +position: absolute;\ +height: 100%;\ +}\ +.ace_text-input {\ +position: absolute;\ +z-index: 0;\ +width: 0.5em;\ +height: 1em;\ +opacity: 0;\ +background: transparent;\ +-moz-appearance: none;\ +appearance: none;\ +border: none;\ +resize: none;\ +outline: none;\ +overflow: hidden;\ +font: inherit;\ +padding: 0 1px;\ +margin: 0 -1px;\ +contain: strict;\ +-ms-user-select: text;\ +-moz-user-select: text;\ +-webkit-user-select: text;\ +user-select: text;\ +white-space: pre!important;\ +}\ +.ace_text-input.ace_composition {\ +background: transparent;\ +color: inherit;\ +z-index: 1000;\ +opacity: 1;\ +}\ +.ace_composition_placeholder { color: transparent }\ +.ace_composition_marker { \ +border-bottom: 1px solid;\ +position: absolute;\ +border-radius: 0;\ +margin-top: 1px;\ +}\ +[ace_nocontext=true] {\ +transform: none!important;\ +filter: none!important;\ +clip-path: none!important;\ +mask : none!important;\ +contain: none!important;\ +perspective: none!important;\ +mix-blend-mode: initial!important;\ +z-index: auto;\ +}\ +.ace_layer {\ +z-index: 1;\ +position: absolute;\ +overflow: hidden;\ +word-wrap: normal;\ +white-space: pre;\ +height: 100%;\ +width: 100%;\ +box-sizing: border-box;\ +pointer-events: none;\ +}\ +.ace_gutter-layer {\ +position: relative;\ +width: auto;\ +text-align: right;\ +pointer-events: auto;\ +height: 1000000px;\ +contain: style size layout;\ +}\ +.ace_text-layer {\ +font: inherit !important;\ +position: absolute;\ +height: 1000000px;\ +width: 1000000px;\ +contain: style size layout;\ +}\ +.ace_text-layer > .ace_line, .ace_text-layer > .ace_line_group {\ +contain: style size layout;\ +position: absolute;\ +top: 0;\ +left: 0;\ +right: 0;\ +}\ +.ace_hidpi .ace_text-layer,\ +.ace_hidpi .ace_gutter-layer,\ +.ace_hidpi .ace_content,\ +.ace_hidpi .ace_gutter {\ +contain: strict;\ +will-change: transform;\ +}\ +.ace_hidpi .ace_text-layer > .ace_line, \ +.ace_hidpi .ace_text-layer > .ace_line_group {\ +contain: strict;\ +}\ +.ace_cjk {\ +display: inline-block;\ +text-align: center;\ +}\ +.ace_cursor-layer {\ +z-index: 4;\ +}\ +.ace_cursor {\ +z-index: 4;\ +position: absolute;\ +box-sizing: border-box;\ +border-left: 2px solid;\ +transform: translatez(0);\ +}\ +.ace_multiselect .ace_cursor {\ +border-left-width: 1px;\ +}\ +.ace_slim-cursors .ace_cursor {\ +border-left-width: 1px;\ +}\ +.ace_overwrite-cursors .ace_cursor {\ +border-left-width: 0;\ +border-bottom: 1px solid;\ +}\ +.ace_hidden-cursors .ace_cursor {\ +opacity: 0.2;\ +}\ +.ace_hasPlaceholder .ace_hidden-cursors .ace_cursor {\ +opacity: 0;\ +}\ +.ace_smooth-blinking .ace_cursor {\ +transition: opacity 0.18s;\ +}\ +.ace_animate-blinking .ace_cursor {\ +animation-duration: 1000ms;\ +animation-timing-function: step-end;\ +animation-name: blink-ace-animate;\ +animation-iteration-count: infinite;\ +}\ +.ace_animate-blinking.ace_smooth-blinking .ace_cursor {\ +animation-duration: 1000ms;\ +animation-timing-function: ease-in-out;\ +animation-name: blink-ace-animate-smooth;\ +}\ +@keyframes blink-ace-animate {\ +from, to { opacity: 1; }\ +60% { opacity: 0; }\ +}\ +@keyframes blink-ace-animate-smooth {\ +from, to { opacity: 1; }\ +45% { opacity: 1; }\ +60% { opacity: 0; }\ +85% { opacity: 0; }\ +}\ +.ace_marker-layer .ace_step, .ace_marker-layer .ace_stack {\ +position: absolute;\ +z-index: 3;\ +}\ +.ace_marker-layer .ace_selection {\ +position: absolute;\ +z-index: 5;\ +}\ +.ace_marker-layer .ace_bracket {\ +position: absolute;\ +z-index: 6;\ +}\ +.ace_marker-layer .ace_error_bracket {\ +position: absolute;\ +border-bottom: 1px solid #DE5555;\ +border-radius: 0;\ +}\ +.ace_marker-layer .ace_active-line {\ +position: absolute;\ +z-index: 2;\ +}\ +.ace_marker-layer .ace_selected-word {\ +position: absolute;\ +z-index: 4;\ +box-sizing: border-box;\ +}\ +.ace_line .ace_fold {\ +box-sizing: border-box;\ +display: inline-block;\ +height: 11px;\ +margin-top: -2px;\ +vertical-align: middle;\ +background-image:\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII=\"),\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACJJREFUeNpi+P//fxgTAwPDBxDxD078RSX+YeEyDFMCIMAAI3INmXiwf2YAAAAASUVORK5CYII=\");\ +background-repeat: no-repeat, repeat-x;\ +background-position: center center, top left;\ +color: transparent;\ +border: 1px solid black;\ +border-radius: 2px;\ +cursor: pointer;\ +pointer-events: auto;\ +}\ +.ace_dark .ace_fold {\ +}\ +.ace_fold:hover{\ +background-image:\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAAJCAYAAADU6McMAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAJpJREFUeNpi/P//PwOlgAXGYGRklAVSokD8GmjwY1wasKljQpYACtpCFeADcHVQfQyMQAwzwAZI3wJKvCLkfKBaMSClBlR7BOQikCFGQEErIH0VqkabiGCAqwUadAzZJRxQr/0gwiXIal8zQQPnNVTgJ1TdawL0T5gBIP1MUJNhBv2HKoQHHjqNrA4WO4zY0glyNKLT2KIfIMAAQsdgGiXvgnYAAAAASUVORK5CYII=\"),\ +url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAA3CAYAAADNNiA5AAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAACBJREFUeNpi+P//fz4TAwPDZxDxD5X4i5fLMEwJgAADAEPVDbjNw87ZAAAAAElFTkSuQmCC\");\ +}\ +.ace_tooltip {\ +background-color: #FFF;\ +background-image: linear-gradient(to bottom, transparent, rgba(0, 0, 0, 0.1));\ +border: 1px solid gray;\ +border-radius: 1px;\ +box-shadow: 0 1px 2px rgba(0, 0, 0, 0.3);\ +color: black;\ +max-width: 100%;\ +padding: 3px 4px;\ +position: fixed;\ +z-index: 999999;\ +box-sizing: border-box;\ +cursor: default;\ +white-space: pre;\ +word-wrap: break-word;\ +line-height: normal;\ +font-style: normal;\ +font-weight: normal;\ +letter-spacing: normal;\ +pointer-events: none;\ +}\ +.ace_folding-enabled > .ace_gutter-cell {\ +padding-right: 13px;\ +}\ +.ace_fold-widget {\ +box-sizing: border-box;\ +margin: 0 -12px 0 1px;\ +display: none;\ +width: 11px;\ +vertical-align: top;\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42mWKsQ0AMAzC8ixLlrzQjzmBiEjp0A6WwBCSPgKAXoLkqSot7nN3yMwR7pZ32NzpKkVoDBUxKAAAAABJRU5ErkJggg==\");\ +background-repeat: no-repeat;\ +background-position: center;\ +border-radius: 3px;\ +border: 1px solid transparent;\ +cursor: pointer;\ +}\ +.ace_folding-enabled .ace_fold-widget {\ +display: inline-block; \ +}\ +.ace_fold-widget.ace_end {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAANElEQVR42m3HwQkAMAhD0YzsRchFKI7sAikeWkrxwScEB0nh5e7KTPWimZki4tYfVbX+MNl4pyZXejUO1QAAAABJRU5ErkJggg==\");\ +}\ +.ace_fold-widget.ace_closed {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAGCAYAAAAG5SQMAAAAOUlEQVR42jXKwQkAMAgDwKwqKD4EwQ26sSOkVWjgIIHAzPiCgaqiqnJHZnKICBERHN194O5b9vbLuAVRL+l0YWnZAAAAAElFTkSuQmCCXA==\");\ +}\ +.ace_fold-widget:hover {\ +border: 1px solid rgba(0, 0, 0, 0.3);\ +background-color: rgba(255, 255, 255, 0.2);\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.7);\ +}\ +.ace_fold-widget:active {\ +border: 1px solid rgba(0, 0, 0, 0.4);\ +background-color: rgba(0, 0, 0, 0.05);\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.8);\ +}\ +.ace_dark .ace_fold-widget {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAHklEQVQIW2P4//8/AzoGEQ7oGCaLLAhWiSwB146BAQCSTPYocqT0AAAAAElFTkSuQmCC\");\ +}\ +.ace_dark .ace_fold-widget.ace_end {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAH0lEQVQIW2P4//8/AxQ7wNjIAjDMgC4AxjCVKBirIAAF0kz2rlhxpAAAAABJRU5ErkJggg==\");\ +}\ +.ace_dark .ace_fold-widget.ace_closed {\ +background-image: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAMAAAAFCAYAAACAcVaiAAAAHElEQVQIW2P4//+/AxAzgDADlOOAznHAKgPWAwARji8UIDTfQQAAAABJRU5ErkJggg==\");\ +}\ +.ace_dark .ace_fold-widget:hover {\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);\ +background-color: rgba(255, 255, 255, 0.1);\ +}\ +.ace_dark .ace_fold-widget:active {\ +box-shadow: 0 1px 1px rgba(255, 255, 255, 0.2);\ +}\ +.ace_inline_button {\ +border: 1px solid lightgray;\ +display: inline-block;\ +margin: -1px 8px;\ +padding: 0 5px;\ +pointer-events: auto;\ +cursor: pointer;\ +}\ +.ace_inline_button:hover {\ +border-color: gray;\ +background: rgba(200,200,200,0.2);\ +display: inline-block;\ +pointer-events: auto;\ +}\ +.ace_fold-widget.ace_invalid {\ +background-color: #FFB4B4;\ +border-color: #DE5555;\ +}\ +.ace_fade-fold-widgets .ace_fold-widget {\ +transition: opacity 0.4s ease 0.05s;\ +opacity: 0;\ +}\ +.ace_fade-fold-widgets:hover .ace_fold-widget {\ +transition: opacity 0.05s ease 0.05s;\ +opacity:1;\ +}\ +.ace_underline {\ +text-decoration: underline;\ +}\ +.ace_bold {\ +font-weight: bold;\ +}\ +.ace_nobold .ace_bold {\ +font-weight: normal;\ +}\ +.ace_italic {\ +font-style: italic;\ +}\ +.ace_error-marker {\ +background-color: rgba(255, 0, 0,0.2);\ +position: absolute;\ +z-index: 9;\ +}\ +.ace_highlight-marker {\ +background-color: rgba(255, 255, 0,0.2);\ +position: absolute;\ +z-index: 8;\ +}\ +.ace_mobile-menu {\ +position: absolute;\ +line-height: 1.5;\ +border-radius: 4px;\ +-ms-user-select: none;\ +-moz-user-select: none;\ +-webkit-user-select: none;\ +user-select: none;\ +background: white;\ +box-shadow: 1px 3px 2px grey;\ +border: 1px solid #dcdcdc;\ +color: black;\ +}\ +.ace_dark > .ace_mobile-menu {\ +background: #333;\ +color: #ccc;\ +box-shadow: 1px 3px 2px grey;\ +border: 1px solid #444;\ +}\ +.ace_mobile-button {\ +padding: 2px;\ +cursor: pointer;\ +overflow: hidden;\ +}\ +.ace_mobile-button:hover {\ +background-color: #eee;\ +opacity:1;\ +}\ +.ace_mobile-button:active {\ +background-color: #ddd;\ +}\ +.ace_placeholder {\ +font-family: arial;\ +transform: scale(0.9);\ +transform-origin: left;\ +white-space: pre;\ +opacity: 0.7;\ +margin: 0 10px;\ +}", useragent = require("./lib/useragent"), HIDE_TEXTAREA = useragent.isIE; + dom.importCssString(editorCss, "ace_editor.css", !1); + var VirtualRenderer = function(container, theme) { + var _self = this; + this.container = container || dom.createElement("div"), dom.addCssClass(this.container, "ace_editor"), dom.HI_DPI && dom.addCssClass(this.container, "ace_hidpi"), this.setTheme(theme), null == config2.get("useStrictCSP") && config2.set("useStrictCSP", !1), this.$gutter = dom.createElement("div"), this.$gutter.className = "ace_gutter", this.container.appendChild(this.$gutter), this.$gutter.setAttribute("aria-hidden", !0), this.scroller = dom.createElement("div"), this.scroller.className = "ace_scroller", this.container.appendChild(this.scroller), this.content = dom.createElement("div"), this.content.className = "ace_content", this.scroller.appendChild(this.content), this.$gutterLayer = new GutterLayer(this.$gutter), this.$gutterLayer.on("changeGutterWidth", this.onGutterResize.bind(this)), this.$markerBack = new MarkerLayer(this.content); + var textLayer = this.$textLayer = new TextLayer(this.content); + this.canvas = textLayer.element, this.$markerFront = new MarkerLayer(this.content), this.$cursorLayer = new CursorLayer(this.content), this.$horizScroll = !1, this.$vScroll = !1, this.scrollBar = this.scrollBarV = new VScrollBar(this.container, this), this.scrollBarH = new HScrollBar(this.container, this), this.scrollBarV.on("scroll", function(e) { + _self.$scrollAnimation || _self.session.setScrollTop(e.data - _self.scrollMargin.top); + }), this.scrollBarH.on("scroll", function(e) { + _self.$scrollAnimation || _self.session.setScrollLeft(e.data - _self.scrollMargin.left); + }), this.scrollTop = 0, this.scrollLeft = 0, this.cursorPos = { + row: 0, + column: 0 + }, this.$fontMetrics = new FontMetrics(this.container), this.$textLayer.$setFontMetrics(this.$fontMetrics), this.$textLayer.on("changeCharacterSize", function(e) { + _self.updateCharacterSize(), _self.onResize(!0, _self.gutterWidth, _self.$size.width, _self.$size.height), _self._signal("changeCharacterSize", e); + }), this.$size = { + width: 0, + height: 0, + scrollerHeight: 0, + scrollerWidth: 0, + $dirty: !0 + }, this.layerConfig = { + width: 1, + padding: 0, + firstRow: 0, + firstRowScreen: 0, + lastRow: 0, + lineHeight: 0, + characterWidth: 0, + minHeight: 1, + maxHeight: 1, + offset: 0, + height: 1, + gutterOffset: 1 + }, this.scrollMargin = { + left: 0, + right: 0, + top: 0, + bottom: 0, + v: 0, + h: 0 + }, this.margin = { + left: 0, + right: 0, + top: 0, + bottom: 0, + v: 0, + h: 0 + }, this.$keepTextAreaAtCursor = !useragent.isIOS, this.$loop = new RenderLoop(this.$renderChanges.bind(this), this.container.ownerDocument.defaultView), this.$loop.schedule(this.CHANGE_FULL), this.updateCharacterSize(), this.setPadding(4), config2.resetOptions(this), config2._signal("renderer", this); + }; + (function() { + this.CHANGE_CURSOR = 1, this.CHANGE_MARKER = 2, this.CHANGE_GUTTER = 4, this.CHANGE_SCROLL = 8, this.CHANGE_LINES = 16, this.CHANGE_TEXT = 32, this.CHANGE_SIZE = 64, this.CHANGE_MARKER_BACK = 128, this.CHANGE_MARKER_FRONT = 256, this.CHANGE_FULL = 512, this.CHANGE_H_SCROLL = 1024, oop.implement(this, EventEmitter), this.updateCharacterSize = function() { + this.$textLayer.allowBoldFonts != this.$allowBoldFonts && (this.$allowBoldFonts = this.$textLayer.allowBoldFonts, this.setStyle("ace_nobold", !this.$allowBoldFonts)), this.layerConfig.characterWidth = this.characterWidth = this.$textLayer.getCharacterWidth(), this.layerConfig.lineHeight = this.lineHeight = this.$textLayer.getLineHeight(), this.$updatePrintMargin(), dom.setStyle(this.scroller.style, "line-height", this.lineHeight + "px"); + }, this.setSession = function(session) { + this.session && this.session.doc.off("changeNewLineMode", this.onChangeNewLineMode), this.session = session, session && this.scrollMargin.top && 0 >= session.getScrollTop() && session.setScrollTop(-this.scrollMargin.top), this.$cursorLayer.setSession(session), this.$markerBack.setSession(session), this.$markerFront.setSession(session), this.$gutterLayer.setSession(session), this.$textLayer.setSession(session), session && (this.$loop.schedule(this.CHANGE_FULL), this.session.$setFontMetrics(this.$fontMetrics), this.scrollBarH.scrollLeft = this.scrollBarV.scrollTop = null, this.onChangeNewLineMode = this.onChangeNewLineMode.bind(this), this.onChangeNewLineMode(), this.session.doc.on("changeNewLineMode", this.onChangeNewLineMode)); + }, this.updateLines = function(firstRow, lastRow, force) { + if (void 0 === lastRow && (lastRow = 1 / 0), this.$changedLines ? (this.$changedLines.firstRow > firstRow && (this.$changedLines.firstRow = firstRow), this.$changedLines.lastRow < lastRow && (this.$changedLines.lastRow = lastRow)) : this.$changedLines = { + firstRow: firstRow, + lastRow: lastRow + }, this.$changedLines.lastRow < this.layerConfig.firstRow) { + if (!force) return; + this.$changedLines.lastRow = this.layerConfig.lastRow; + } + this.$changedLines.firstRow > this.layerConfig.lastRow || this.$loop.schedule(this.CHANGE_LINES); + }, this.onChangeNewLineMode = function() { + this.$loop.schedule(this.CHANGE_TEXT), this.$textLayer.$updateEolChar(), this.session.$bidiHandler.setEolChar(this.$textLayer.EOL_CHAR); + }, this.onChangeTabSize = function() { + this.$loop.schedule(this.CHANGE_TEXT | this.CHANGE_MARKER), this.$textLayer.onChangeTabSize(); + }, this.updateText = function() { + this.$loop.schedule(this.CHANGE_TEXT); + }, this.updateFull = function(force) { + force ? this.$renderChanges(this.CHANGE_FULL, !0) : this.$loop.schedule(this.CHANGE_FULL); + }, this.updateFontSize = function() { + this.$textLayer.checkForSizeChanges(); + }, this.$changes = 0, this.$updateSizeAsync = function() { + this.$loop.pending ? this.$size.$dirty = !0 : this.onResize(); + }, this.onResize = function(force, gutterWidth, width, height) { + if (!(this.resizing > 2)) { + this.resizing > 0 ? this.resizing++ : this.resizing = force ? 1 : 0; + var el = this.container; + height || (height = el.clientHeight || el.scrollHeight), width || (width = el.clientWidth || el.scrollWidth); + var changes = this.$updateCachedSize(force, gutterWidth, width, height); + if (!this.$size.scrollerHeight || !width && !height) return this.resizing = 0; + force && (this.$gutterLayer.$padding = null), force ? this.$renderChanges(changes | this.$changes, !0) : this.$loop.schedule(changes | this.$changes), this.resizing && (this.resizing = 0), this.scrollBarH.scrollLeft = this.scrollBarV.scrollTop = null; + } + }, this.$updateCachedSize = function(force, gutterWidth, width, height) { + height -= this.$extraHeight || 0; + var changes = 0, size = this.$size, oldSize = { + width: size.width, + height: size.height, + scrollerHeight: size.scrollerHeight, + scrollerWidth: size.scrollerWidth + }; + if (height && (force || size.height != height) && (size.height = height, changes |= this.CHANGE_SIZE, size.scrollerHeight = size.height, this.$horizScroll && (size.scrollerHeight -= this.scrollBarH.getHeight()), this.scrollBarV.element.style.bottom = this.scrollBarH.getHeight() + "px", changes |= this.CHANGE_SCROLL), width && (force || size.width != width)) { + changes |= this.CHANGE_SIZE, size.width = width, null == gutterWidth && (gutterWidth = this.$showGutter ? this.$gutter.offsetWidth : 0), this.gutterWidth = gutterWidth, dom.setStyle(this.scrollBarH.element.style, "left", gutterWidth + "px"), dom.setStyle(this.scroller.style, "left", gutterWidth + this.margin.left + "px"), size.scrollerWidth = Math.max(0, width - gutterWidth - this.scrollBarV.getWidth() - this.margin.h), dom.setStyle(this.$gutter.style, "left", this.margin.left + "px"); + var right = this.scrollBarV.getWidth() + "px"; + dom.setStyle(this.scrollBarH.element.style, "right", right), dom.setStyle(this.scroller.style, "right", right), dom.setStyle(this.scroller.style, "bottom", this.scrollBarH.getHeight()), (this.session && this.session.getUseWrapMode() && this.adjustWrapLimit() || force) && (changes |= this.CHANGE_FULL); + } + return size.$dirty = !width || !height, changes && this._signal("resize", oldSize), changes; + }, this.onGutterResize = function(width) { + var gutterWidth = this.$showGutter ? width : 0; + gutterWidth != this.gutterWidth && (this.$changes |= this.$updateCachedSize(!0, gutterWidth, this.$size.width, this.$size.height)), this.session.getUseWrapMode() && this.adjustWrapLimit() ? this.$loop.schedule(this.CHANGE_FULL) : this.$size.$dirty ? this.$loop.schedule(this.CHANGE_FULL) : this.$computeLayerConfig(); + }, this.adjustWrapLimit = function() { + var limit = Math.floor((this.$size.scrollerWidth - 2 * this.$padding) / this.characterWidth); + return this.session.adjustWrapLimit(limit, this.$showPrintMargin && this.$printMarginColumn); + }, this.setAnimatedScroll = function(shouldAnimate) { + this.setOption("animatedScroll", shouldAnimate); + }, this.getAnimatedScroll = function() { + return this.$animatedScroll; + }, this.setShowInvisibles = function(showInvisibles) { + this.setOption("showInvisibles", showInvisibles), this.session.$bidiHandler.setShowInvisibles(showInvisibles); + }, this.getShowInvisibles = function() { + return this.getOption("showInvisibles"); + }, this.getDisplayIndentGuides = function() { + return this.getOption("displayIndentGuides"); + }, this.setDisplayIndentGuides = function(display) { + this.setOption("displayIndentGuides", display); + }, this.setShowPrintMargin = function(showPrintMargin) { + this.setOption("showPrintMargin", showPrintMargin); + }, this.getShowPrintMargin = function() { + return this.getOption("showPrintMargin"); + }, this.setPrintMarginColumn = function(showPrintMargin) { + this.setOption("printMarginColumn", showPrintMargin); + }, this.getPrintMarginColumn = function() { + return this.getOption("printMarginColumn"); + }, this.getShowGutter = function() { + return this.getOption("showGutter"); + }, this.setShowGutter = function(show) { + return this.setOption("showGutter", show); + }, this.getFadeFoldWidgets = function() { + return this.getOption("fadeFoldWidgets"); + }, this.setFadeFoldWidgets = function(show) { + this.setOption("fadeFoldWidgets", show); + }, this.setHighlightGutterLine = function(shouldHighlight) { + this.setOption("highlightGutterLine", shouldHighlight); + }, this.getHighlightGutterLine = function() { + return this.getOption("highlightGutterLine"); + }, this.$updatePrintMargin = function() { + if (this.$showPrintMargin || this.$printMarginEl) { + if (!this.$printMarginEl) { + var containerEl = dom.createElement("div"); + containerEl.className = "ace_layer ace_print-margin-layer", this.$printMarginEl = dom.createElement("div"), this.$printMarginEl.className = "ace_print-margin", containerEl.appendChild(this.$printMarginEl), this.content.insertBefore(containerEl, this.content.firstChild); + } + var style = this.$printMarginEl.style; + style.left = Math.round(this.characterWidth * this.$printMarginColumn + this.$padding) + "px", style.visibility = this.$showPrintMargin ? "visible" : "hidden", this.session && -1 == this.session.$wrap && this.adjustWrapLimit(); + } + }, this.getContainerElement = function() { + return this.container; + }, this.getMouseEventTarget = function() { + return this.scroller; + }, this.getTextAreaContainer = function() { + return this.container; + }, this.$moveTextAreaToCursor = function() { + if (!this.$isMousePressed) { + var style = this.textarea.style, composition = this.$composition; + if (!this.$keepTextAreaAtCursor && !composition) { + dom.translate(this.textarea, -100, 0); + return; + } + var pixelPos = this.$cursorLayer.$pixelPos; + if (pixelPos) { + composition && composition.markerRange && (pixelPos = this.$cursorLayer.getPixelPosition(composition.markerRange.start, !0)); + var config = this.layerConfig, posTop = pixelPos.top, posLeft = pixelPos.left; + posTop -= config.offset; + var h = composition && composition.useTextareaForIME ? this.lineHeight : HIDE_TEXTAREA ? 0 : 1; + if (posTop < 0 || posTop > config.height - h) { + dom.translate(this.textarea, 0, 0); + return; + } + var w = 1, maxTop = this.$size.height - h; + if (composition) if (composition.useTextareaForIME) { + var val = this.textarea.value; + w = this.characterWidth * this.session.$getStringScreenWidth(val)[0]; + } else posTop += this.lineHeight + 2; + else posTop += this.lineHeight; + (posLeft -= this.scrollLeft) > this.$size.scrollerWidth - w && (posLeft = this.$size.scrollerWidth - w), posLeft += this.gutterWidth + this.margin.left, dom.setStyle(style, "height", h + "px"), dom.setStyle(style, "width", w + "px"), dom.translate(this.textarea, Math.min(posLeft, this.$size.scrollerWidth - w), Math.min(posTop, maxTop)); + } + } + }, this.getFirstVisibleRow = function() { + return this.layerConfig.firstRow; + }, this.getFirstFullyVisibleRow = function() { + return this.layerConfig.firstRow + (0 === this.layerConfig.offset ? 0 : 1); + }, this.getLastFullyVisibleRow = function() { + var config = this.layerConfig, lastRow = config.lastRow; + return this.session.documentToScreenRow(lastRow, 0) * config.lineHeight - this.session.getScrollTop() > config.height - config.lineHeight ? lastRow - 1 : lastRow; + }, this.getLastVisibleRow = function() { + return this.layerConfig.lastRow; + }, this.$padding = null, this.setPadding = function(padding) { + this.$padding = padding, this.$textLayer.setPadding(padding), this.$cursorLayer.setPadding(padding), this.$markerFront.setPadding(padding), this.$markerBack.setPadding(padding), this.$loop.schedule(this.CHANGE_FULL), this.$updatePrintMargin(); + }, this.setScrollMargin = function(top, bottom, left, right) { + var sm = this.scrollMargin; + sm.top = 0 | top, sm.bottom = 0 | bottom, sm.right = 0 | right, sm.left = 0 | left, sm.v = sm.top + sm.bottom, sm.h = sm.left + sm.right, sm.top && this.scrollTop <= 0 && this.session && this.session.setScrollTop(-sm.top), this.updateFull(); + }, this.setMargin = function(top, bottom, left, right) { + var sm = this.margin; + sm.top = 0 | top, sm.bottom = 0 | bottom, sm.right = 0 | right, sm.left = 0 | left, sm.v = sm.top + sm.bottom, sm.h = sm.left + sm.right, this.$updateCachedSize(!0, this.gutterWidth, this.$size.width, this.$size.height), this.updateFull(); + }, this.getHScrollBarAlwaysVisible = function() { + return this.$hScrollBarAlwaysVisible; + }, this.setHScrollBarAlwaysVisible = function(alwaysVisible) { + this.setOption("hScrollBarAlwaysVisible", alwaysVisible); + }, this.getVScrollBarAlwaysVisible = function() { + return this.$vScrollBarAlwaysVisible; + }, this.setVScrollBarAlwaysVisible = function(alwaysVisible) { + this.setOption("vScrollBarAlwaysVisible", alwaysVisible); + }, this.$updateScrollBarV = function() { + var scrollHeight = this.layerConfig.maxHeight, scrollerHeight = this.$size.scrollerHeight; + !this.$maxLines && this.$scrollPastEnd && (scrollHeight -= (scrollerHeight - this.lineHeight) * this.$scrollPastEnd, this.scrollTop > scrollHeight - scrollerHeight && (scrollHeight = this.scrollTop + scrollerHeight, this.scrollBarV.scrollTop = null)), this.scrollBarV.setScrollHeight(scrollHeight + this.scrollMargin.v), this.scrollBarV.setScrollTop(this.scrollTop + this.scrollMargin.top); + }, this.$updateScrollBarH = function() { + this.scrollBarH.setScrollWidth(this.layerConfig.width + 2 * this.$padding + this.scrollMargin.h), this.scrollBarH.setScrollLeft(this.scrollLeft + this.scrollMargin.left); + }, this.$frozen = !1, this.freeze = function() { + this.$frozen = !0; + }, this.unfreeze = function() { + this.$frozen = !1; + }, this.$renderChanges = function(changes, force) { + if (this.$changes && (changes |= this.$changes, this.$changes = 0), !this.session || !this.container.offsetWidth || this.$frozen || !changes && !force) { + this.$changes |= changes; + return; + } + if (this.$size.$dirty) return this.$changes |= changes, this.onResize(!0); + this.lineHeight || this.$textLayer.checkForSizeChanges(), this._signal("beforeRender", changes), this.session && this.session.$bidiHandler && this.session.$bidiHandler.updateCharacterWidths(this.$fontMetrics); + var config = this.layerConfig; + if (changes & this.CHANGE_FULL || changes & this.CHANGE_SIZE || changes & this.CHANGE_TEXT || changes & this.CHANGE_LINES || changes & this.CHANGE_SCROLL || changes & this.CHANGE_H_SCROLL) { + if (changes |= this.$computeLayerConfig() | this.$loop.clear(), config.firstRow != this.layerConfig.firstRow && config.firstRowScreen == this.layerConfig.firstRowScreen) { + var st = this.scrollTop + (config.firstRow - this.layerConfig.firstRow) * this.lineHeight; + st > 0 && (this.scrollTop = st, changes |= this.CHANGE_SCROLL, changes |= this.$computeLayerConfig() | this.$loop.clear()); + } + config = this.layerConfig, this.$updateScrollBarV(), changes & this.CHANGE_H_SCROLL && this.$updateScrollBarH(), dom.translate(this.content, -this.scrollLeft, -config.offset); + var width = config.width + 2 * this.$padding + "px", height = config.minHeight + "px"; + dom.setStyle(this.content.style, "width", width), dom.setStyle(this.content.style, "height", height); + } + if (changes & this.CHANGE_H_SCROLL && (dom.translate(this.content, -this.scrollLeft, -config.offset), this.scroller.className = this.scrollLeft <= 0 ? "ace_scroller" : "ace_scroller ace_scroll-left"), changes & this.CHANGE_FULL) { + this.$changedLines = null, this.$textLayer.update(config), this.$showGutter && this.$gutterLayer.update(config), this.$markerBack.update(config), this.$markerFront.update(config), this.$cursorLayer.update(config), this.$moveTextAreaToCursor(), this._signal("afterRender", changes); + return; + } + if (changes & this.CHANGE_SCROLL) { + this.$changedLines = null, changes & this.CHANGE_TEXT || changes & this.CHANGE_LINES ? this.$textLayer.update(config) : this.$textLayer.scrollLines(config), this.$showGutter && (changes & this.CHANGE_GUTTER || changes & this.CHANGE_LINES ? this.$gutterLayer.update(config) : this.$gutterLayer.scrollLines(config)), this.$markerBack.update(config), this.$markerFront.update(config), this.$cursorLayer.update(config), this.$moveTextAreaToCursor(), this._signal("afterRender", changes); + return; + } + changes & this.CHANGE_TEXT ? (this.$changedLines = null, this.$textLayer.update(config), this.$showGutter && this.$gutterLayer.update(config)) : changes & this.CHANGE_LINES ? (this.$updateLines() || changes & this.CHANGE_GUTTER && this.$showGutter) && this.$gutterLayer.update(config) : changes & this.CHANGE_TEXT || changes & this.CHANGE_GUTTER ? this.$showGutter && this.$gutterLayer.update(config) : changes & this.CHANGE_CURSOR && this.$highlightGutterLine && this.$gutterLayer.updateLineHighlight(config), changes & this.CHANGE_CURSOR && (this.$cursorLayer.update(config), this.$moveTextAreaToCursor()), changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_FRONT) && this.$markerFront.update(config), changes & (this.CHANGE_MARKER | this.CHANGE_MARKER_BACK) && this.$markerBack.update(config), this._signal("afterRender", changes); + }, this.$autosize = function() { + var height = this.session.getScreenLength() * this.lineHeight, maxHeight = this.$maxLines * this.lineHeight, desiredHeight = Math.min(maxHeight, Math.max((this.$minLines || 1) * this.lineHeight, height)) + this.scrollMargin.v + (this.$extraHeight || 0); + this.$horizScroll && (desiredHeight += this.scrollBarH.getHeight()), this.$maxPixelHeight && desiredHeight > this.$maxPixelHeight && (desiredHeight = this.$maxPixelHeight); + var vScroll = !(desiredHeight <= 2 * this.lineHeight) && height > maxHeight; + if (desiredHeight != this.desiredHeight || this.$size.height != this.desiredHeight || vScroll != this.$vScroll) { + vScroll != this.$vScroll && (this.$vScroll = vScroll, this.scrollBarV.setVisible(vScroll)); + var w = this.container.clientWidth; + this.container.style.height = desiredHeight + "px", this.$updateCachedSize(!0, this.$gutterWidth, w, desiredHeight), this.desiredHeight = desiredHeight, this._signal("autosize"); + } + }, this.$computeLayerConfig = function() { + var firstRowScreen, firstRowHeight, session = this.session, size = this.$size, hideScrollbars = size.height <= 2 * this.lineHeight, maxHeight = this.session.getScreenLength() * this.lineHeight, longestLine = this.$getLongestLine(), horizScroll = !hideScrollbars && (this.$hScrollBarAlwaysVisible || size.scrollerWidth - longestLine - 2 * this.$padding < 0), hScrollChanged = this.$horizScroll !== horizScroll; + hScrollChanged && (this.$horizScroll = horizScroll, this.scrollBarH.setVisible(horizScroll)); + var vScrollBefore = this.$vScroll; + this.$maxLines && this.lineHeight > 1 && this.$autosize(); + var minHeight = size.scrollerHeight + this.lineHeight, scrollPastEnd = !this.$maxLines && this.$scrollPastEnd ? (size.scrollerHeight - this.lineHeight) * this.$scrollPastEnd : 0; + maxHeight += scrollPastEnd; + var sm = this.scrollMargin; + this.session.setScrollTop(Math.max(-sm.top, Math.min(this.scrollTop, maxHeight - size.scrollerHeight + sm.bottom))), this.session.setScrollLeft(Math.max(-sm.left, Math.min(this.scrollLeft, longestLine + 2 * this.$padding - size.scrollerWidth + sm.right))); + var vScroll = !hideScrollbars && (this.$vScrollBarAlwaysVisible || size.scrollerHeight - maxHeight + scrollPastEnd < 0 || this.scrollTop > sm.top), vScrollChanged = vScrollBefore !== vScroll; + vScrollChanged && (this.$vScroll = vScroll, this.scrollBarV.setVisible(vScroll)); + var offset = this.scrollTop % this.lineHeight, lineCount = Math.ceil(minHeight / this.lineHeight) - 1, firstRow = Math.max(0, Math.round((this.scrollTop - offset) / this.lineHeight)), lastRow = firstRow + lineCount, lineHeight = this.lineHeight; + firstRow = session.screenToDocumentRow(firstRow, 0); + var foldLine = session.getFoldLine(firstRow); + foldLine && (firstRow = foldLine.start.row), firstRowScreen = session.documentToScreenRow(firstRow, 0), firstRowHeight = session.getRowLength(firstRow) * lineHeight, lastRow = Math.min(session.screenToDocumentRow(lastRow, 0), session.getLength() - 1), minHeight = size.scrollerHeight + session.getRowLength(lastRow) * lineHeight + firstRowHeight, offset = this.scrollTop - firstRowScreen * lineHeight; + var changes = 0; + return (this.layerConfig.width != longestLine || hScrollChanged) && (changes = this.CHANGE_H_SCROLL), (hScrollChanged || vScrollChanged) && (changes |= this.$updateCachedSize(!0, this.gutterWidth, size.width, size.height), this._signal("scrollbarVisibilityChanged"), vScrollChanged && (longestLine = this.$getLongestLine())), this.layerConfig = { + width: longestLine, + padding: this.$padding, + firstRow: firstRow, + firstRowScreen: firstRowScreen, + lastRow: lastRow, + lineHeight: lineHeight, + characterWidth: this.characterWidth, + minHeight: minHeight, + maxHeight: maxHeight, + offset: offset, + gutterOffset: lineHeight ? Math.max(0, Math.ceil((offset + size.height - size.scrollerHeight) / lineHeight)) : 0, + height: this.$size.scrollerHeight + }, this.session.$bidiHandler && this.session.$bidiHandler.setContentWidth(longestLine - this.$padding), changes; + }, this.$updateLines = function() { + if (this.$changedLines) { + var firstRow = this.$changedLines.firstRow, lastRow = this.$changedLines.lastRow; + this.$changedLines = null; + var layerConfig = this.layerConfig; + if (!(firstRow > layerConfig.lastRow + 1) && !(lastRow < layerConfig.firstRow)) { + if (lastRow === 1 / 0) { + this.$showGutter && this.$gutterLayer.update(layerConfig), this.$textLayer.update(layerConfig); + return; + } + return this.$textLayer.updateLines(layerConfig, firstRow, lastRow), !0; + } + } + }, this.$getLongestLine = function() { + var charCount = this.session.getScreenWidth(); + return this.showInvisibles && !this.session.$useWrapMode && (charCount += 1), this.$textLayer && charCount > this.$textLayer.MAX_LINE_LENGTH && (charCount = this.$textLayer.MAX_LINE_LENGTH + 30), Math.max(this.$size.scrollerWidth - 2 * this.$padding, Math.round(charCount * this.characterWidth)); + }, this.updateFrontMarkers = function() { + this.$markerFront.setMarkers(this.session.getMarkers(!0)), this.$loop.schedule(this.CHANGE_MARKER_FRONT); + }, this.updateBackMarkers = function() { + this.$markerBack.setMarkers(this.session.getMarkers()), this.$loop.schedule(this.CHANGE_MARKER_BACK); + }, this.addGutterDecoration = function(row, className) { + this.$gutterLayer.addGutterDecoration(row, className); + }, this.removeGutterDecoration = function(row, className) { + this.$gutterLayer.removeGutterDecoration(row, className); + }, this.updateBreakpoints = function(rows) { + this.$loop.schedule(this.CHANGE_GUTTER); + }, this.setAnnotations = function(annotations) { + this.$gutterLayer.setAnnotations(annotations), this.$loop.schedule(this.CHANGE_GUTTER); + }, this.updateCursor = function() { + this.$loop.schedule(this.CHANGE_CURSOR); + }, this.hideCursor = function() { + this.$cursorLayer.hideCursor(); + }, this.showCursor = function() { + this.$cursorLayer.showCursor(); + }, this.scrollSelectionIntoView = function(anchor, lead, offset) { + this.scrollCursorIntoView(anchor, offset), this.scrollCursorIntoView(lead, offset); + }, this.scrollCursorIntoView = function(cursor, offset, $viewMargin) { + if (0 !== this.$size.scrollerHeight) { + var pos = this.$cursorLayer.getPixelPosition(cursor), left = pos.left, top = pos.top, topMargin = $viewMargin && $viewMargin.top || 0, bottomMargin = $viewMargin && $viewMargin.bottom || 0, scrollTop = this.$scrollAnimation ? this.session.getScrollTop() : this.scrollTop; + scrollTop + topMargin > top ? (offset && scrollTop + topMargin > top + this.lineHeight && (top -= offset * this.$size.scrollerHeight), 0 === top && (top = -this.scrollMargin.top), this.session.setScrollTop(top)) : scrollTop + this.$size.scrollerHeight - bottomMargin < top + this.lineHeight && (offset && scrollTop + this.$size.scrollerHeight - bottomMargin < top - this.lineHeight && (top += offset * this.$size.scrollerHeight), this.session.setScrollTop(top + this.lineHeight + bottomMargin - this.$size.scrollerHeight)); + var scrollLeft = this.scrollLeft; + scrollLeft > left ? (left < this.$padding + 2 * this.layerConfig.characterWidth && (left = -this.scrollMargin.left), this.session.setScrollLeft(left)) : scrollLeft + this.$size.scrollerWidth < left + this.characterWidth ? this.session.setScrollLeft(Math.round(left + this.characterWidth - this.$size.scrollerWidth)) : scrollLeft <= this.$padding && left - scrollLeft < this.characterWidth && this.session.setScrollLeft(0); + } + }, this.getScrollTop = function() { + return this.session.getScrollTop(); + }, this.getScrollLeft = function() { + return this.session.getScrollLeft(); + }, this.getScrollTopRow = function() { + return this.scrollTop / this.lineHeight; + }, this.getScrollBottomRow = function() { + return Math.max(0, Math.floor((this.scrollTop + this.$size.scrollerHeight) / this.lineHeight) - 1); + }, this.scrollToRow = function(row) { + this.session.setScrollTop(row * this.lineHeight); + }, this.alignCursor = function(cursor, alignment) { + "number" == typeof cursor && (cursor = { + row: cursor, + column: 0 + }); + var pos = this.$cursorLayer.getPixelPosition(cursor), h = this.$size.scrollerHeight - this.lineHeight, offset = pos.top - h * (alignment || 0); + return this.session.setScrollTop(offset), offset; + }, this.STEPS = 8, this.$calcSteps = function(fromValue, toValue) { + var t, x_min, dx, i = 0, l = this.STEPS, steps = []; + for(i = 0; i < l; ++i)steps.push((t = i / this.STEPS, x_min = fromValue, dx = toValue - fromValue, dx * (Math.pow(t - 1, 3) + 1) + x_min)); + return steps; + }, this.scrollToLine = function(line, center, animate, callback) { + var offset = this.$cursorLayer.getPixelPosition({ + row: line, + column: 0 + }).top; + center && (offset -= this.$size.scrollerHeight / 2); + var initialScroll = this.scrollTop; + this.session.setScrollTop(offset), !1 !== animate && this.animateScrolling(initialScroll, callback); + }, this.animateScrolling = function(fromValue, callback) { + var toValue = this.scrollTop; + if (this.$animatedScroll) { + var _self = this; + if (fromValue != toValue) { + if (this.$scrollAnimation) { + var oldSteps = this.$scrollAnimation.steps; + if (oldSteps.length && (fromValue = oldSteps[0]) == toValue) return; + } + var steps = _self.$calcSteps(fromValue, toValue); + this.$scrollAnimation = { + from: fromValue, + to: toValue, + steps: steps + }, clearInterval(this.$timer), _self.session.setScrollTop(steps.shift()), _self.session.$scrollTop = toValue, this.$timer = setInterval(function() { + if (!_self.session) return clearInterval(_self.$timer); + steps.length ? (_self.session.setScrollTop(steps.shift()), _self.session.$scrollTop = toValue) : null != toValue ? (_self.session.$scrollTop = -1, _self.session.setScrollTop(toValue), toValue = null) : (_self.$timer = clearInterval(_self.$timer), _self.$scrollAnimation = null, callback && callback()); + }, 10); + } + } + }, this.scrollToY = function(scrollTop) { + this.scrollTop !== scrollTop && (this.$loop.schedule(this.CHANGE_SCROLL), this.scrollTop = scrollTop); + }, this.scrollToX = function(scrollLeft) { + this.scrollLeft !== scrollLeft && (this.scrollLeft = scrollLeft), this.$loop.schedule(this.CHANGE_H_SCROLL); + }, this.scrollTo = function(x, y) { + this.session.setScrollTop(y), this.session.setScrollLeft(x); + }, this.scrollBy = function(deltaX, deltaY) { + deltaY && this.session.setScrollTop(this.session.getScrollTop() + deltaY), deltaX && this.session.setScrollLeft(this.session.getScrollLeft() + deltaX); + }, this.isScrollableBy = function(deltaX, deltaY) { + return !!(deltaY < 0 && this.session.getScrollTop() >= 1 - this.scrollMargin.top) || !!(deltaY > 0 && this.session.getScrollTop() + this.$size.scrollerHeight - this.layerConfig.maxHeight < -1 + this.scrollMargin.bottom) || !!(deltaX < 0 && this.session.getScrollLeft() >= 1 - this.scrollMargin.left) || !!(deltaX > 0 && this.session.getScrollLeft() + this.$size.scrollerWidth - this.layerConfig.width < -1 + this.scrollMargin.right) || void 0; + }, this.pixelToScreenCoordinates = function(x, y) { + if (this.$hasCssTransforms) { + canvasPos = { + top: 0, + left: 0 + }; + var canvasPos, p = this.$fontMetrics.transformCoordinates([ + x, + y + ]); + x = p[1] - this.gutterWidth - this.margin.left, y = p[0]; + } else canvasPos = this.scroller.getBoundingClientRect(); + var offsetX = x + this.scrollLeft - canvasPos.left - this.$padding, offset = offsetX / this.characterWidth, row = Math.floor((y + this.scrollTop - canvasPos.top) / this.lineHeight), col = this.$blockCursor ? Math.floor(offset) : Math.round(offset); + return { + row: row, + column: col, + side: offset - col > 0 ? 1 : -1, + offsetX: offsetX + }; + }, this.screenToTextCoordinates = function(x, y) { + if (this.$hasCssTransforms) { + canvasPos = { + top: 0, + left: 0 + }; + var canvasPos, p = this.$fontMetrics.transformCoordinates([ + x, + y + ]); + x = p[1] - this.gutterWidth - this.margin.left, y = p[0]; + } else canvasPos = this.scroller.getBoundingClientRect(); + var offsetX = x + this.scrollLeft - canvasPos.left - this.$padding, offset = offsetX / this.characterWidth, col = this.$blockCursor ? Math.floor(offset) : Math.round(offset), row = Math.floor((y + this.scrollTop - canvasPos.top) / this.lineHeight); + return this.session.screenToDocumentPosition(row, Math.max(col, 0), offsetX); + }, this.textToScreenCoordinates = function(row, column) { + var canvasPos = this.scroller.getBoundingClientRect(), pos = this.session.documentToScreenPosition(row, column), x = this.$padding + (this.session.$bidiHandler.isBidiRow(pos.row, row) ? this.session.$bidiHandler.getPosLeft(pos.column) : Math.round(pos.column * this.characterWidth)), y = pos.row * this.lineHeight; + return { + pageX: canvasPos.left + x - this.scrollLeft, + pageY: canvasPos.top + y - this.scrollTop + }; + }, this.visualizeFocus = function() { + dom.addCssClass(this.container, "ace_focus"); + }, this.visualizeBlur = function() { + dom.removeCssClass(this.container, "ace_focus"); + }, this.showComposition = function(composition) { + this.$composition = composition, composition.cssText || (composition.cssText = this.textarea.style.cssText), void 0 == composition.useTextareaForIME && (composition.useTextareaForIME = this.$useTextareaForIME), this.$useTextareaForIME ? (dom.addCssClass(this.textarea, "ace_composition"), this.textarea.style.cssText = "", this.$moveTextAreaToCursor(), this.$cursorLayer.element.style.display = "none") : composition.markerId = this.session.addMarker(composition.markerRange, "ace_composition_marker", "text"); + }, this.setCompositionText = function(text) { + var cursor = this.session.selection.cursor; + this.addToken(text, "composition_placeholder", cursor.row, cursor.column), this.$moveTextAreaToCursor(); + }, this.hideComposition = function() { + if (this.$composition) { + this.$composition.markerId && this.session.removeMarker(this.$composition.markerId), dom.removeCssClass(this.textarea, "ace_composition"), this.textarea.style.cssText = this.$composition.cssText; + var cursor = this.session.selection.cursor; + this.removeExtraToken(cursor.row, cursor.column), this.$composition = null, this.$cursorLayer.element.style.display = ""; + } + }, this.addToken = function(text, type, row, column) { + var session = this.session; + session.bgTokenizer.lines[row] = null; + var newToken = { + type: type, + value: text + }, tokens = session.getTokens(row); + if (null == column) tokens.push(newToken); + else for(var l = 0, i = 0; i < tokens.length; i++){ + var token = tokens[i]; + if (column <= (l += token.value.length)) { + var diff = token.value.length - (l - column), before = token.value.slice(0, diff), after = token.value.slice(diff); + tokens.splice(i, 1, { + type: token.type, + value: before + }, newToken, { + type: token.type, + value: after + }); + break; + } + } + this.updateLines(row, row); + }, this.removeExtraToken = function(row, column) { + this.updateLines(row, row); + }, this.setTheme = function(theme, cb) { + var _self = this; + if (this.$themeId = theme, _self._dispatchEvent('themeChange', { + theme: theme + }), theme && "string" != typeof theme) afterLoad(theme); + else { + var moduleName = theme || this.$options.theme.initialValue; + config2.loadModule([ + "theme", + moduleName + ], afterLoad); + } + function afterLoad(module) { + if (_self.$themeId != theme) return cb && cb(); + if (!module || !module.cssClass) throw new Error("couldn't load module " + theme + " or it didn't call define"); + module.$id && (_self.$themeId = module.$id), dom.importCssString(module.cssText, module.cssClass, _self.container), _self.theme && dom.removeCssClass(_self.container, _self.theme.cssClass); + var padding = "padding" in module ? module.padding : "padding" in (_self.theme || {}) ? 4 : _self.$padding; + _self.$padding && padding != _self.$padding && _self.setPadding(padding), _self.$theme = module.cssClass, _self.theme = module, dom.addCssClass(_self.container, module.cssClass), dom.setCssClass(_self.container, "ace_dark", module.isDark), _self.$size && (_self.$size.width = 0, _self.$updateSizeAsync()), _self._dispatchEvent('themeLoaded', { + theme: module + }), cb && cb(); + } + }, this.getTheme = function() { + return this.$themeId; + }, this.setStyle = function(style, include) { + dom.setCssClass(this.container, style, !1 !== include); + }, this.unsetStyle = function(style) { + dom.removeCssClass(this.container, style); + }, this.setCursorStyle = function(style) { + dom.setStyle(this.scroller.style, "cursor", style); + }, this.setMouseCursor = function(cursorStyle) { + dom.setStyle(this.scroller.style, "cursor", cursorStyle); + }, this.attachToShadowRoot = function() { + dom.importCssString(editorCss, "ace_editor.css", this.container); + }, this.destroy = function() { + this.freeze(), this.$fontMetrics.destroy(), this.$cursorLayer.destroy(), this.removeAllListeners(), this.container.textContent = ""; + }; + }).call(VirtualRenderer.prototype), config2.defineOptions(VirtualRenderer.prototype, "renderer", { + animatedScroll: { + initialValue: !1 + }, + showInvisibles: { + set: function(value) { + this.$textLayer.setShowInvisibles(value) && this.$loop.schedule(this.CHANGE_TEXT); + }, + initialValue: !1 + }, + showPrintMargin: { + set: function() { + this.$updatePrintMargin(); + }, + initialValue: !0 + }, + printMarginColumn: { + set: function() { + this.$updatePrintMargin(); + }, + initialValue: 80 + }, + printMargin: { + set: function(val) { + "number" == typeof val && (this.$printMarginColumn = val), this.$showPrintMargin = !!val, this.$updatePrintMargin(); + }, + get: function() { + return this.$showPrintMargin && this.$printMarginColumn; + } + }, + showGutter: { + set: function(show) { + this.$gutter.style.display = show ? "block" : "none", this.$loop.schedule(this.CHANGE_FULL), this.onGutterResize(); + }, + initialValue: !0 + }, + fadeFoldWidgets: { + set: function(show) { + dom.setCssClass(this.$gutter, "ace_fade-fold-widgets", show); + }, + initialValue: !1 + }, + showFoldWidgets: { + set: function(show) { + this.$gutterLayer.setShowFoldWidgets(show), this.$loop.schedule(this.CHANGE_GUTTER); + }, + initialValue: !0 + }, + displayIndentGuides: { + set: function(show) { + this.$textLayer.setDisplayIndentGuides(show) && this.$loop.schedule(this.CHANGE_TEXT); + }, + initialValue: !0 + }, + highlightGutterLine: { + set: function(shouldHighlight) { + this.$gutterLayer.setHighlightGutterLine(shouldHighlight), this.$loop.schedule(this.CHANGE_GUTTER); + }, + initialValue: !0 + }, + hScrollBarAlwaysVisible: { + set: function(val) { + this.$hScrollBarAlwaysVisible && this.$horizScroll || this.$loop.schedule(this.CHANGE_SCROLL); + }, + initialValue: !1 + }, + vScrollBarAlwaysVisible: { + set: function(val) { + this.$vScrollBarAlwaysVisible && this.$vScroll || this.$loop.schedule(this.CHANGE_SCROLL); + }, + initialValue: !1 + }, + fontSize: { + set: function(size) { + "number" == typeof size && (size += "px"), this.container.style.fontSize = size, this.updateFontSize(); + }, + initialValue: 12 + }, + fontFamily: { + set: function(name) { + this.container.style.fontFamily = name, this.updateFontSize(); + } + }, + maxLines: { + set: function(val) { + this.updateFull(); + } + }, + minLines: { + set: function(val) { + this.$minLines < 562949953421311 || (this.$minLines = 0), this.updateFull(); + } + }, + maxPixelHeight: { + set: function(val) { + this.updateFull(); + }, + initialValue: 0 + }, + scrollPastEnd: { + set: function(val) { + val = +val || 0, this.$scrollPastEnd != val && (this.$scrollPastEnd = val, this.$loop.schedule(this.CHANGE_SCROLL)); + }, + initialValue: 0, + handlesSet: !0 + }, + fixedWidthGutter: { + set: function(val) { + this.$gutterLayer.$fixedWidth = !!val, this.$loop.schedule(this.CHANGE_GUTTER); + } + }, + theme: { + set: function(val) { + this.setTheme(val); + }, + get: function() { + return this.$themeId || this.theme; + }, + initialValue: "./theme/textmate", + handlesSet: !0 + }, + hasCssTransforms: {}, + useTextareaForIME: { + initialValue: !useragent.isMobile && !useragent.isIE + } + }), exports.VirtualRenderer = VirtualRenderer; + }), ace.define("ace/worker/worker_client", [ + "require", + "exports", + "module", + "ace/lib/oop", + "ace/lib/net", + "ace/lib/event_emitter", + "ace/config" + ], function(require, exports, module) { + "use strict"; + var oop = require("../lib/oop"), net = require("../lib/net"), EventEmitter = require("../lib/event_emitter").EventEmitter, config = require("../config"); + function createWorker(workerUrl1) { + if ("undefined" == typeof Worker) return { + postMessage: function() {}, + terminate: function() {} + }; + if (config.get("loadWorkerFromBlob")) { + var blob = function(workerUrl) { + var script = "importScripts('" + net.qualifyURL(workerUrl) + "');"; + try { + return new Blob([ + script + ], { + type: "application/javascript" + }); + } catch (e) { + var blobBuilder = new (window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder)(); + return blobBuilder.append(script), blobBuilder.getBlob("application/javascript"); + } + }(workerUrl1), blobURL = (window.URL || window.webkitURL).createObjectURL(blob); + return new Worker(blobURL); + } + return new Worker(workerUrl1); + } + var WorkerClient = function(worker) { + worker.postMessage || (worker = this.$createWorkerFromOldConfig.apply(this, arguments)), this.$worker = worker, this.$sendDeltaQueue = this.$sendDeltaQueue.bind(this), this.changeListener = this.changeListener.bind(this), this.onMessage = this.onMessage.bind(this), this.callbackId = 1, this.callbacks = {}, this.$worker.onmessage = this.onMessage; + }; + (function() { + oop.implement(this, EventEmitter), this.$createWorkerFromOldConfig = function(topLevelNamespaces, mod, classname, workerUrl, importScripts) { + if (require.nameToUrl && !require.toUrl && (require.toUrl = require.nameToUrl), config.get("packaged") || !require.toUrl) workerUrl = workerUrl || config.moduleUrl(mod, "worker"); + else { + var normalizePath = this.$normalizePath; + workerUrl = workerUrl || normalizePath(require.toUrl("ace/worker/worker.js", null, "_")); + var tlns = {}; + topLevelNamespaces.forEach(function(ns) { + tlns[ns] = normalizePath(require.toUrl(ns, null, "_").replace(/(\.js)?(\?.*)?$/, "")); + }); + } + return this.$worker = createWorker(workerUrl), importScripts && this.send("importScripts", importScripts), this.$worker.postMessage({ + init: !0, + tlns: tlns, + module: mod, + classname: classname + }), this.$worker; + }, this.onMessage = function(e) { + var msg = e.data; + switch(msg.type){ + case "event": + this._signal(msg.name, { + data: msg.data + }); + break; + case "call": + var callback = this.callbacks[msg.id]; + callback && (callback(msg.data), delete this.callbacks[msg.id]); + break; + case "error": + this.reportError(msg.data); + break; + case "log": + window.console && console.log && console.log.apply(console, msg.data); + break; + } + }, this.reportError = function(err) { + window.console && console.error && console.error(err); + }, this.$normalizePath = function(path) { + return net.qualifyURL(path); + }, this.terminate = function() { + this._signal("terminate", {}), this.deltaQueue = null, this.$worker.terminate(), this.$worker = null, this.$doc && this.$doc.off("change", this.changeListener), this.$doc = null; + }, this.send = function(cmd, args) { + this.$worker.postMessage({ + command: cmd, + args: args + }); + }, this.call = function(cmd, args, callback) { + if (callback) { + var id = this.callbackId++; + this.callbacks[id] = callback, args.push(id); + } + this.send(cmd, args); + }, this.emit = function(event, data) { + try { + data.data && data.data.err && (data.data.err = { + message: data.data.err.message, + stack: data.data.err.stack, + code: data.data.err.code + }), this.$worker.postMessage({ + event: event, + data: { + data: data.data + } + }); + } catch (ex) { + console.error(ex.stack); + } + }, this.attachToDocument = function(doc) { + this.$doc && this.terminate(), this.$doc = doc, this.call("setValue", [ + doc.getValue() + ]), doc.on("change", this.changeListener); + }, this.changeListener = function(delta) { + this.deltaQueue || (this.deltaQueue = [], setTimeout(this.$sendDeltaQueue, 0)), "insert" == delta.action ? this.deltaQueue.push(delta.start, delta.lines) : this.deltaQueue.push(delta.start, delta.end); + }, this.$sendDeltaQueue = function() { + var q = this.deltaQueue; + q && (this.deltaQueue = null, q.length > 50 && q.length > this.$doc.getLength() >> 1 ? this.call("setValue", [ + this.$doc.getValue() + ]) : this.emit("change", { + data: q + })); + }; + }).call(WorkerClient.prototype), exports.UIWorkerClient = function(topLevelNamespaces, mod, classname) { + var main = null, emitSync = !1, sender = Object.create(EventEmitter), messageBuffer = [], workerClient = new WorkerClient({ + messageBuffer: messageBuffer, + terminate: function() {}, + postMessage: function(e) { + messageBuffer.push(e), main && (emitSync ? setTimeout(processNext) : processNext()); + } + }); + workerClient.setEmitSync = function(val) { + emitSync = val; + }; + var processNext = function() { + var msg = messageBuffer.shift(); + msg.command ? main[msg.command].apply(main, msg.args) : msg.event && sender._signal(msg.event, msg.data); + }; + return sender.postMessage = function(msg) { + workerClient.onMessage({ + data: msg + }); + }, sender.callback = function(data, callbackId) { + this.postMessage({ + type: "call", + id: callbackId, + data: data + }); + }, sender.emit = function(name, data) { + this.postMessage({ + type: "event", + name: name, + data: data + }); + }, config.loadModule([ + "worker", + mod + ], function(Main) { + for(main = new Main[classname](sender); messageBuffer.length;)processNext(); + }), workerClient; + }, exports.WorkerClient = WorkerClient, exports.createWorker = createWorker; + }), ace.define("ace/placeholder", [ + "require", + "exports", + "module", + "ace/range", + "ace/lib/event_emitter", + "ace/lib/oop" + ], function(require, exports, module) { + "use strict"; + var Range = require("./range").Range, EventEmitter = require("./lib/event_emitter").EventEmitter, oop = require("./lib/oop"), PlaceHolder = function(session, length, pos, others, mainClass, othersClass) { + var _self = this; + this.length = length, this.session = session, this.doc = session.getDocument(), this.mainClass = mainClass, this.othersClass = othersClass, this.$onUpdate = this.onUpdate.bind(this), this.doc.on("change", this.$onUpdate), this.$others = others, this.$onCursorChange = function() { + setTimeout(function() { + _self.onCursorChange(); + }); + }, this.$pos = pos; + var undoStack = session.getUndoManager().$undoStack || session.getUndoManager().$undostack || { + length: -1 + }; + this.$undoStackDepth = undoStack.length, this.setup(), session.selection.on("changeCursor", this.$onCursorChange); + }; + (function() { + oop.implement(this, EventEmitter), this.setup = function() { + var _self = this, doc = this.doc, session = this.session; + this.selectionBefore = session.selection.toJSON(), session.selection.inMultiSelectMode && session.selection.toSingleRange(), this.pos = doc.createAnchor(this.$pos.row, this.$pos.column); + var pos = this.pos; + pos.$insertRight = !0, pos.detach(), pos.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column + this.length), this.mainClass, null, !1), this.others = [], this.$others.forEach(function(other) { + var anchor = doc.createAnchor(other.row, other.column); + anchor.$insertRight = !0, anchor.detach(), _self.others.push(anchor); + }), session.setUndoSelect(!1); + }, this.showOtherMarkers = function() { + if (!this.othersActive) { + var session = this.session, _self = this; + this.othersActive = !0, this.others.forEach(function(anchor) { + anchor.markerId = session.addMarker(new Range(anchor.row, anchor.column, anchor.row, anchor.column + _self.length), _self.othersClass, null, !1); + }); + } + }, this.hideOtherMarkers = function() { + if (this.othersActive) { + this.othersActive = !1; + for(var i = 0; i < this.others.length; i++)this.session.removeMarker(this.others[i].markerId); + } + }, this.onUpdate = function(delta) { + if (this.$updating) return this.updateAnchors(delta); + var range = delta; + if (range.start.row === range.end.row && range.start.row === this.pos.row) { + this.$updating = !0; + var lengthDiff = "insert" === delta.action ? range.end.column - range.start.column : range.start.column - range.end.column, inMainRange = range.start.column >= this.pos.column && range.start.column <= this.pos.column + this.length + 1, distanceFromStart = range.start.column - this.pos.column; + if (this.updateAnchors(delta), inMainRange && (this.length += lengthDiff), inMainRange && !this.session.$fromUndo) { + if ('insert' === delta.action) for(var i = this.others.length - 1; i >= 0; i--){ + var otherPos = this.others[i], newPos = { + row: otherPos.row, + column: otherPos.column + distanceFromStart + }; + this.doc.insertMergedLines(newPos, delta.lines); + } + else if ('remove' === delta.action) for(var i = this.others.length - 1; i >= 0; i--){ + var otherPos = this.others[i], newPos = { + row: otherPos.row, + column: otherPos.column + distanceFromStart + }; + this.doc.remove(new Range(newPos.row, newPos.column, newPos.row, newPos.column - lengthDiff)); + } + } + this.$updating = !1, this.updateMarkers(); + } + }, this.updateAnchors = function(delta) { + this.pos.onChange(delta); + for(var i = this.others.length; i--;)this.others[i].onChange(delta); + this.updateMarkers(); + }, this.updateMarkers = function() { + if (!this.$updating) { + var _self = this, session = this.session, updateMarker = function(pos, className) { + session.removeMarker(pos.markerId), pos.markerId = session.addMarker(new Range(pos.row, pos.column, pos.row, pos.column + _self.length), className, null, !1); + }; + updateMarker(this.pos, this.mainClass); + for(var i = this.others.length; i--;)updateMarker(this.others[i], this.othersClass); + } + }, this.onCursorChange = function(event) { + if (!this.$updating && this.session) { + var pos = this.session.selection.getCursor(); + pos.row === this.pos.row && pos.column >= this.pos.column && pos.column <= this.pos.column + this.length ? (this.showOtherMarkers(), this._emit("cursorEnter", event)) : (this.hideOtherMarkers(), this._emit("cursorLeave", event)); + } + }, this.detach = function() { + this.session.removeMarker(this.pos && this.pos.markerId), this.hideOtherMarkers(), this.doc.off("change", this.$onUpdate), this.session.selection.off("changeCursor", this.$onCursorChange), this.session.setUndoSelect(!0), this.session = null; + }, this.cancel = function() { + if (-1 !== this.$undoStackDepth) { + for(var undoManager = this.session.getUndoManager(), undosRequired = (undoManager.$undoStack || undoManager.$undostack).length - this.$undoStackDepth, i = 0; i < undosRequired; i++)undoManager.undo(this.session, !0); + this.selectionBefore && this.session.selection.fromJSON(this.selectionBefore); + } + }; + }).call(PlaceHolder.prototype), exports.PlaceHolder = PlaceHolder; + }), ace.define("ace/mouse/multi_select_handler", [ + "require", + "exports", + "module", + "ace/lib/event", + "ace/lib/useragent" + ], function(require, exports, module) { + var event = require("../lib/event"), useragent = require("../lib/useragent"); + function isSamePoint(p1, p2) { + return p1.row == p2.row && p1.column == p2.column; + } + exports.onMouseDown = function(e5) { + var ev = e5.domEvent, alt = ev.altKey, shift = ev.shiftKey, ctrl = ev.ctrlKey, accel = e5.getAccelKey(), button = e5.getButton(); + if (ctrl && useragent.isMac && (button = ev.button), e5.editor.inMultiSelectMode && 2 == button) { + e5.editor.textInput.onContextMenu(e5.domEvent); + return; + } + if (!ctrl && !alt && !accel) { + 0 === button && e5.editor.inMultiSelectMode && e5.editor.exitMultiSelectMode(); + return; + } + if (0 === button) { + var editor = e5.editor, selection = editor.selection, isMultiSelect = editor.inMultiSelectMode, pos = e5.getDocumentPosition(), cursor2 = selection.getCursor(), inSelection = e5.inSelection() || selection.isEmpty() && isSamePoint(pos, cursor2), mouseX = e5.x, mouseY = e5.y, onMouseSelection = function(e) { + mouseX = e.clientX, mouseY = e.clientY; + }, session = editor.session, screenAnchor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY), screenCursor = screenAnchor; + if (editor.$mouseHandler.$enableJumpToDef) ctrl && alt || accel && alt ? selectionMode = shift ? "block" : "add" : alt && editor.$blockSelectEnabled && (selectionMode = "block"); + else if (accel && !alt) { + if (selectionMode = "add", !isMultiSelect && shift) return; + } else alt && editor.$blockSelectEnabled && (selectionMode = "block"); + if (selectionMode && useragent.isMac && ev.ctrlKey && editor.$mouseHandler.cancelContextMenu(), "add" == selectionMode) { + if (!isMultiSelect && inSelection) return; + if (!isMultiSelect) { + var range = selection.toOrientedRange(); + editor.addSelectionMarker(range); + } + var oldRange = selection.rangeList.rangeAtPoint(pos); + editor.inVirtualSelectionMode = !0, shift && (oldRange = null, range = selection.ranges[0] || range, editor.removeSelectionMarker(range)), editor.once("mouseup", function() { + var tmpSel = selection.toOrientedRange(); + oldRange && tmpSel.isEmpty() && isSamePoint(oldRange.cursor, tmpSel.cursor) ? selection.substractPoint(tmpSel.cursor) : (shift ? selection.substractPoint(range.cursor) : range && (editor.removeSelectionMarker(range), selection.addRange(range)), selection.addRange(tmpSel)), editor.inVirtualSelectionMode = !1; + }); + } else if ("block" == selectionMode) { + e5.stop(), editor.inVirtualSelectionMode = !0; + var selectionMode, initialRange, rectSel = [], blockSelect = function() { + var newCursor = editor.renderer.pixelToScreenCoordinates(mouseX, mouseY), cursor = session.screenToDocumentPosition(newCursor.row, newCursor.column, newCursor.offsetX); + isSamePoint(screenCursor, newCursor) && isSamePoint(cursor, selection.lead) || (screenCursor = newCursor, editor.selection.moveToPosition(cursor), editor.renderer.scrollCursorIntoView(), editor.removeSelectionMarkers(rectSel), rectSel = selection.rectangularRangeBlock(screenCursor, screenAnchor), editor.$mouseHandler.$clickSelection && 1 == rectSel.length && rectSel[0].isEmpty() && (rectSel[0] = editor.$mouseHandler.$clickSelection.clone()), rectSel.forEach(editor.addSelectionMarker, editor), editor.updateSelectionMarkers()); + }; + isMultiSelect && !accel ? selection.toSingleRange() : !isMultiSelect && accel && (initialRange = selection.toOrientedRange(), editor.addSelectionMarker(initialRange)), shift ? screenAnchor = session.documentToScreenPosition(selection.lead) : selection.moveToPosition(pos), screenCursor = { + row: -1, + column: -1 + }; + var onMouseSelectionEnd = function(e) { + blockSelect(), clearInterval(timerId), editor.removeSelectionMarkers(rectSel), rectSel.length || (rectSel = [ + selection.toOrientedRange() + ]), initialRange && (editor.removeSelectionMarker(initialRange), selection.toSingleRange(initialRange)); + for(var i = 0; i < rectSel.length; i++)selection.addRange(rectSel[i]); + editor.inVirtualSelectionMode = !1, editor.$mouseHandler.$clickSelection = null; + }, onSelectionInterval = blockSelect; + event.capture(editor.container, onMouseSelection, onMouseSelectionEnd); + var timerId = setInterval(function() { + onSelectionInterval(); + }, 20); + return e5.preventDefault(); + } + } + }; + }), ace.define("ace/commands/multi_select_commands", [ + "require", + "exports", + "module", + "ace/keyboard/hash_handler" + ], function(require, exports, module) { + exports.defaultCommands = [ + { + name: "addCursorAbove", + description: "Add cursor above", + exec: function(editor) { + editor.selectMoreLines(-1); + }, + bindKey: { + win: "Ctrl-Alt-Up", + mac: "Ctrl-Alt-Up" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "addCursorBelow", + description: "Add cursor below", + exec: function(editor) { + editor.selectMoreLines(1); + }, + bindKey: { + win: "Ctrl-Alt-Down", + mac: "Ctrl-Alt-Down" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "addCursorAboveSkipCurrent", + description: "Add cursor above (skip current)", + exec: function(editor) { + editor.selectMoreLines(-1, !0); + }, + bindKey: { + win: "Ctrl-Alt-Shift-Up", + mac: "Ctrl-Alt-Shift-Up" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "addCursorBelowSkipCurrent", + description: "Add cursor below (skip current)", + exec: function(editor) { + editor.selectMoreLines(1, !0); + }, + bindKey: { + win: "Ctrl-Alt-Shift-Down", + mac: "Ctrl-Alt-Shift-Down" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectMoreBefore", + description: "Select more before", + exec: function(editor) { + editor.selectMore(-1); + }, + bindKey: { + win: "Ctrl-Alt-Left", + mac: "Ctrl-Alt-Left" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectMoreAfter", + description: "Select more after", + exec: function(editor) { + editor.selectMore(1); + }, + bindKey: { + win: "Ctrl-Alt-Right", + mac: "Ctrl-Alt-Right" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectNextBefore", + description: "Select next before", + exec: function(editor) { + editor.selectMore(-1, !0); + }, + bindKey: { + win: "Ctrl-Alt-Shift-Left", + mac: "Ctrl-Alt-Shift-Left" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "selectNextAfter", + description: "Select next after", + exec: function(editor) { + editor.selectMore(1, !0); + }, + bindKey: { + win: "Ctrl-Alt-Shift-Right", + mac: "Ctrl-Alt-Shift-Right" + }, + scrollIntoView: "cursor", + readOnly: !0 + }, + { + name: "toggleSplitSelectionIntoLines", + description: "Split into lines", + exec: function(editor) { + editor.multiSelect.rangeCount > 1 ? editor.multiSelect.joinSelections() : editor.multiSelect.splitIntoLines(); + }, + bindKey: { + win: "Ctrl-Alt-L", + mac: "Ctrl-Alt-L" + }, + readOnly: !0 + }, + { + name: "splitSelectionIntoLines", + description: "Split into lines", + exec: function(editor) { + editor.multiSelect.splitIntoLines(); + }, + readOnly: !0 + }, + { + name: "alignCursors", + description: "Align cursors", + exec: function(editor) { + editor.alignCursors(); + }, + bindKey: { + win: "Ctrl-Alt-A", + mac: "Ctrl-Alt-A" + }, + scrollIntoView: "cursor" + }, + { + name: "findAll", + description: "Find all", + exec: function(editor) { + editor.findAll(); + }, + bindKey: { + win: "Ctrl-Alt-K", + mac: "Ctrl-Alt-G" + }, + scrollIntoView: "cursor", + readOnly: !0 + } + ], exports.multiSelectCommands = [ + { + name: "singleSelection", + description: "Single selection", + bindKey: "esc", + exec: function(editor) { + editor.exitMultiSelectMode(); + }, + scrollIntoView: "cursor", + readOnly: !0, + isAvailable: function(editor) { + return editor && editor.inMultiSelectMode; + } + } + ]; + var HashHandler = require("../keyboard/hash_handler").HashHandler; + exports.keyboardHandler = new HashHandler(exports.multiSelectCommands); + }), ace.define("ace/multi_select", [ + "require", + "exports", + "module", + "ace/range_list", + "ace/range", + "ace/selection", + "ace/mouse/multi_select_handler", + "ace/lib/event", + "ace/lib/lang", + "ace/commands/multi_select_commands", + "ace/search", + "ace/edit_session", + "ace/editor", + "ace/config" + ], function(require, exports, module) { + var RangeList = require("./range_list").RangeList, Range = require("./range").Range, Selection = require("./selection").Selection, onMouseDown = require("./mouse/multi_select_handler").onMouseDown, event = require("./lib/event"), lang = require("./lib/lang"), commands = require("./commands/multi_select_commands"); + exports.commands = commands.defaultCommands.concat(commands.multiSelectCommands); + var search = new (require("./search")).Search(), EditSession = require("./edit_session").EditSession; + (function() { + this.getSelectionMarkers = function() { + return this.$selectionMarkers; + }; + }).call(EditSession.prototype), (function() { + this.ranges = null, this.rangeList = null, this.addRange = function(range, $blockChangeEvents) { + if (range) { + if (!this.inMultiSelectMode && 0 === this.rangeCount) { + var oldRange = this.toOrientedRange(); + if (this.rangeList.add(oldRange), this.rangeList.add(range), 2 != this.rangeList.ranges.length) return this.rangeList.removeAll(), $blockChangeEvents || this.fromOrientedRange(range); + this.rangeList.removeAll(), this.rangeList.add(oldRange), this.$onAddRange(oldRange); + } + range.cursor || (range.cursor = range.end); + var removed = this.rangeList.add(range); + return this.$onAddRange(range), removed.length && this.$onRemoveRange(removed), this.rangeCount > 1 && !this.inMultiSelectMode && (this._signal("multiSelect"), this.inMultiSelectMode = !0, this.session.$undoSelect = !1, this.rangeList.attach(this.session)), $blockChangeEvents || this.fromOrientedRange(range); + } + }, this.toSingleRange = function(range) { + range = range || this.ranges[0]; + var removed = this.rangeList.removeAll(); + removed.length && this.$onRemoveRange(removed), range && this.fromOrientedRange(range); + }, this.substractPoint = function(pos) { + var removed = this.rangeList.substractPoint(pos); + if (removed) return this.$onRemoveRange(removed), removed[0]; + }, this.mergeOverlappingRanges = function() { + var removed = this.rangeList.merge(); + removed.length && this.$onRemoveRange(removed); + }, this.$onAddRange = function(range) { + this.rangeCount = this.rangeList.ranges.length, this.ranges.unshift(range), this._signal("addRange", { + range: range + }); + }, this.$onRemoveRange = function(removed) { + if (this.rangeCount = this.rangeList.ranges.length, 1 == this.rangeCount && this.inMultiSelectMode) { + var lastRange = this.rangeList.ranges.pop(); + removed.push(lastRange), this.rangeCount = 0; + } + for(var i = removed.length; i--;){ + var index = this.ranges.indexOf(removed[i]); + this.ranges.splice(index, 1); + } + this._signal("removeRange", { + ranges: removed + }), 0 === this.rangeCount && this.inMultiSelectMode && (this.inMultiSelectMode = !1, this._signal("singleSelect"), this.session.$undoSelect = !0, this.rangeList.detach(this.session)), (lastRange = lastRange || this.ranges[0]) && !lastRange.isEqual(this.getRange()) && this.fromOrientedRange(lastRange); + }, this.$initRangeList = function() { + this.rangeList || (this.rangeList = new RangeList(), this.ranges = [], this.rangeCount = 0); + }, this.getAllRanges = function() { + return this.rangeCount ? this.rangeList.ranges.concat() : [ + this.getRange() + ]; + }, this.splitIntoLines = function() { + for(var ranges = this.ranges.length ? this.ranges : [ + this.getRange() + ], newRanges = [], i = 0; i < ranges.length; i++){ + var range = ranges[i], row = range.start.row, endRow = range.end.row; + if (row === endRow) newRanges.push(range.clone()); + else { + for(newRanges.push(new Range(row, range.start.column, row, this.session.getLine(row).length)); ++row < endRow;)newRanges.push(this.getLineRange(row, !0)); + newRanges.push(new Range(endRow, 0, endRow, range.end.column)); + } + 0 != i || this.isBackwards() || (newRanges = newRanges.reverse()); + } + this.toSingleRange(); + for(var i = newRanges.length; i--;)this.addRange(newRanges[i]); + }, this.joinSelections = function() { + var ranges = this.rangeList.ranges, lastRange = ranges[ranges.length - 1], range = Range.fromPoints(ranges[0].start, lastRange.end); + this.toSingleRange(), this.setSelectionRange(range, lastRange.cursor == lastRange.start); + }, this.toggleBlockSelection = function() { + if (this.rangeCount > 1) { + var ranges = this.rangeList.ranges, lastRange = ranges[ranges.length - 1], range = Range.fromPoints(ranges[0].start, lastRange.end); + this.toSingleRange(), this.setSelectionRange(range, lastRange.cursor == lastRange.start); + } else { + var cursor = this.session.documentToScreenPosition(this.cursor), anchor = this.session.documentToScreenPosition(this.anchor); + this.rectangularRangeBlock(cursor, anchor).forEach(this.addRange, this); + } + }, this.rectangularRangeBlock = function(screenCursor, screenAnchor, includeEmptyLines) { + var docEnd, rectSel = [], xBackwards = screenCursor.column < screenAnchor.column; + if (xBackwards) var startColumn = screenCursor.column, endColumn = screenAnchor.column, startOffsetX = screenCursor.offsetX, endOffsetX = screenAnchor.offsetX; + else var startColumn = screenAnchor.column, endColumn = screenCursor.column, startOffsetX = screenAnchor.offsetX, endOffsetX = screenCursor.offsetX; + var yBackwards = screenCursor.row < screenAnchor.row; + if (yBackwards) var startRow = screenCursor.row, endRow = screenAnchor.row; + else var startRow = screenAnchor.row, endRow = screenCursor.row; + startColumn < 0 && (startColumn = 0), startRow < 0 && (startRow = 0), startRow == endRow && (includeEmptyLines = !0); + for(var row = startRow; row <= endRow; row++){ + var range = Range.fromPoints(this.session.screenToDocumentPosition(row, startColumn, startOffsetX), this.session.screenToDocumentPosition(row, endColumn, endOffsetX)); + if (range.isEmpty()) { + if (docEnd && isSamePoint(range.end, docEnd)) break; + docEnd = range.end; + } + range.cursor = xBackwards ? range.start : range.end, rectSel.push(range); + } + if (yBackwards && rectSel.reverse(), !includeEmptyLines) { + for(var end = rectSel.length - 1; rectSel[end].isEmpty() && end > 0;)end--; + if (end > 0) for(var start = 0; rectSel[start].isEmpty();)start++; + for(var i = end; i >= start; i--)rectSel[i].isEmpty() && rectSel.splice(i, 1); + } + return rectSel; + }; + }).call(Selection.prototype); + var Editor = require("./editor").Editor; + function isSamePoint(p1, p2) { + return p1.row == p2.row && p1.column == p2.column; + } + function MultiSelect(editor) { + editor.$multiselectOnSessionChange || (editor.$onAddRange = editor.$onAddRange.bind(editor), editor.$onRemoveRange = editor.$onRemoveRange.bind(editor), editor.$onMultiSelect = editor.$onMultiSelect.bind(editor), editor.$onSingleSelect = editor.$onSingleSelect.bind(editor), editor.$multiselectOnSessionChange = exports.onSessionChange.bind(editor), editor.$checkMultiselectChange = editor.$checkMultiselectChange.bind(editor), editor.$multiselectOnSessionChange(editor), editor.on("changeSession", editor.$multiselectOnSessionChange), editor.on("mousedown", onMouseDown), editor.commands.addCommands(commands.defaultCommands), addAltCursorListeners(editor)); + } + function addAltCursorListeners(editor) { + if (editor.textInput) { + var el = editor.textInput.getElement(), altCursor = !1; + event.addListener(el, "keydown", function(e) { + var altDown = 18 == e.keyCode && !(e.ctrlKey || e.shiftKey || e.metaKey); + editor.$blockSelectEnabled && altDown ? altCursor || (editor.renderer.setMouseCursor("crosshair"), altCursor = !0) : altCursor && reset(); + }, editor), event.addListener(el, "keyup", reset, editor), event.addListener(el, "blur", reset, editor); + } + function reset(e) { + altCursor && (editor.renderer.setMouseCursor(""), altCursor = !1); + } + } + (function() { + this.updateSelectionMarkers = function() { + this.renderer.updateCursor(), this.renderer.updateBackMarkers(); + }, this.addSelectionMarker = function(orientedRange) { + orientedRange.cursor || (orientedRange.cursor = orientedRange.end); + var style = this.getSelectionStyle(); + return orientedRange.marker = this.session.addMarker(orientedRange, "ace_selection", style), this.session.$selectionMarkers.push(orientedRange), this.session.selectionMarkerCount = this.session.$selectionMarkers.length, orientedRange; + }, this.removeSelectionMarker = function(range) { + if (range.marker) { + this.session.removeMarker(range.marker); + var index = this.session.$selectionMarkers.indexOf(range); + -1 != index && this.session.$selectionMarkers.splice(index, 1), this.session.selectionMarkerCount = this.session.$selectionMarkers.length; + } + }, this.removeSelectionMarkers = function(ranges) { + for(var markerList = this.session.$selectionMarkers, i = ranges.length; i--;){ + var range = ranges[i]; + if (range.marker) { + this.session.removeMarker(range.marker); + var index = markerList.indexOf(range); + -1 != index && markerList.splice(index, 1); + } + } + this.session.selectionMarkerCount = markerList.length; + }, this.$onAddRange = function(e) { + this.addSelectionMarker(e.range), this.renderer.updateCursor(), this.renderer.updateBackMarkers(); + }, this.$onRemoveRange = function(e) { + this.removeSelectionMarkers(e.ranges), this.renderer.updateCursor(), this.renderer.updateBackMarkers(); + }, this.$onMultiSelect = function(e) { + this.inMultiSelectMode || (this.inMultiSelectMode = !0, this.setStyle("ace_multiselect"), this.keyBinding.addKeyboardHandler(commands.keyboardHandler), this.commands.setDefaultHandler("exec", this.$onMultiSelectExec), this.renderer.updateCursor(), this.renderer.updateBackMarkers()); + }, this.$onSingleSelect = function(e) { + this.session.multiSelect.inVirtualMode || (this.inMultiSelectMode = !1, this.unsetStyle("ace_multiselect"), this.keyBinding.removeKeyboardHandler(commands.keyboardHandler), this.commands.removeDefaultHandler("exec", this.$onMultiSelectExec), this.renderer.updateCursor(), this.renderer.updateBackMarkers(), this._emit("changeSelection")); + }, this.$onMultiSelectExec = function(e) { + var command = e.command, editor = e.editor; + if (editor.multiSelect) { + if (command.multiSelectAction) "forEach" == command.multiSelectAction ? result = editor.forEachSelection(command, e.args) : "forEachLine" == command.multiSelectAction ? result = editor.forEachSelection(command, e.args, !0) : "single" == command.multiSelectAction ? (editor.exitMultiSelectMode(), result = command.exec(editor, e.args || {})) : result = command.multiSelectAction(editor, e.args || {}); + else { + var result = command.exec(editor, e.args || {}); + editor.multiSelect.addRange(editor.multiSelect.toOrientedRange()), editor.multiSelect.mergeOverlappingRanges(); + } + return result; + } + }, this.forEachSelection = function(cmd, args, options) { + if (!this.inVirtualSelectionMode) { + var result, keepOrder = options && options.keepOrder, $byLines = !0 == options || options && options.$byLines, session = this.session, selection = this.selection, rangeList = selection.rangeList, ranges = (keepOrder ? selection : rangeList).ranges; + if (!ranges.length) return cmd.exec ? cmd.exec(this, args || {}) : cmd(this, args || {}); + var reg = selection._eventRegistry; + selection._eventRegistry = {}; + var tmpSel = new Selection(session); + this.inVirtualSelectionMode = !0; + for(var i = ranges.length; i--;){ + if ($byLines) for(; i > 0 && ranges[i].start.row == ranges[i - 1].end.row;)i--; + tmpSel.fromOrientedRange(ranges[i]), tmpSel.index = i, this.selection = session.selection = tmpSel; + var cmdResult = cmd.exec ? cmd.exec(this, args || {}) : cmd(this, args || {}); + result || void 0 === cmdResult || (result = cmdResult), tmpSel.toOrientedRange(ranges[i]); + } + tmpSel.detach(), this.selection = session.selection = selection, this.inVirtualSelectionMode = !1, selection._eventRegistry = reg, selection.mergeOverlappingRanges(), selection.ranges[0] && selection.fromOrientedRange(selection.ranges[0]); + var anim = this.renderer.$scrollAnimation; + return this.onCursorChange(), this.onSelectionChange(), anim && anim.from == anim.to && this.renderer.animateScrolling(anim.from), result; + } + }, this.exitMultiSelectMode = function() { + this.inMultiSelectMode && !this.inVirtualSelectionMode && this.multiSelect.toSingleRange(); + }, this.getSelectedText = function() { + var text = ""; + if (this.inMultiSelectMode && !this.inVirtualSelectionMode) { + for(var ranges = this.multiSelect.rangeList.ranges, buf = [], i = 0; i < ranges.length; i++)buf.push(this.session.getTextRange(ranges[i])); + var nl = this.session.getDocument().getNewLineCharacter(); + (text = buf.join(nl)).length == (buf.length - 1) * nl.length && (text = ""); + } else this.selection.isEmpty() || (text = this.session.getTextRange(this.getSelectionRange())); + return text; + }, this.$checkMultiselectChange = function(e, anchor) { + if (this.inMultiSelectMode && !this.inVirtualSelectionMode) { + var range = this.multiSelect.ranges[0]; + if (!this.multiSelect.isEmpty() || anchor != this.multiSelect.anchor) { + var pos = anchor == this.multiSelect.anchor ? range.cursor == range.start ? range.end : range.start : range.cursor; + pos.row != anchor.row || this.session.$clipPositionToDocument(pos.row, pos.column).column != anchor.column ? this.multiSelect.toSingleRange(this.multiSelect.toOrientedRange()) : this.multiSelect.mergeOverlappingRanges(); + } + } + }, this.findAll = function(needle, options, additive) { + if ((options = options || {}).needle = needle || options.needle, void 0 == options.needle) { + var range = this.selection.isEmpty() ? this.selection.getWordRange() : this.selection.getRange(); + options.needle = this.session.getTextRange(range); + } + this.$search.set(options); + var ranges = this.$search.findAll(this.session); + if (!ranges.length) return 0; + var selection = this.multiSelect; + additive || selection.toSingleRange(ranges[0]); + for(var i = ranges.length; i--;)selection.addRange(ranges[i], !0); + return range && selection.rangeList.rangeAtPoint(range.start) && selection.addRange(range, !0), ranges.length; + }, this.selectMoreLines = function(dir, skip) { + var range = this.selection.toOrientedRange(), isBackwards = range.cursor == range.end, screenLead = this.session.documentToScreenPosition(range.cursor); + this.selection.$desiredColumn && (screenLead.column = this.selection.$desiredColumn); + var lead = this.session.screenToDocumentPosition(screenLead.row + dir, screenLead.column); + if (range.isEmpty()) var anchor = lead; + else var screenAnchor = this.session.documentToScreenPosition(isBackwards ? range.end : range.start), anchor = this.session.screenToDocumentPosition(screenAnchor.row + dir, screenAnchor.column); + if (isBackwards) { + var newRange = Range.fromPoints(lead, anchor); + newRange.cursor = newRange.start; + } else { + var newRange = Range.fromPoints(anchor, lead); + newRange.cursor = newRange.end; + } + if (newRange.desiredColumn = screenLead.column, this.selection.inMultiSelectMode) { + if (skip) var toRemove = range.cursor; + } else this.selection.addRange(range); + this.selection.addRange(newRange), toRemove && this.selection.substractPoint(toRemove); + }, this.transposeSelections = function(dir) { + for(var session = this.session, sel = session.multiSelect, all = sel.ranges, i = all.length; i--;){ + var range = all[i]; + if (range.isEmpty()) { + var tmp = session.getWordRange(range.start.row, range.start.column); + range.start.row = tmp.start.row, range.start.column = tmp.start.column, range.end.row = tmp.end.row, range.end.column = tmp.end.column; + } + } + sel.mergeOverlappingRanges(); + for(var words = [], i = all.length; i--;){ + var range = all[i]; + words.unshift(session.getTextRange(range)); + } + dir < 0 ? words.unshift(words.pop()) : words.push(words.shift()); + for(var i = all.length; i--;){ + var range = all[i], tmp = range.clone(); + session.replace(range, words[i]), range.start.row = tmp.start.row, range.start.column = tmp.start.column; + } + sel.fromOrientedRange(sel.ranges[0]); + }, this.selectMore = function(dir, skip, stopAtFirst) { + var session = this.session, range = session.multiSelect.toOrientedRange(); + if (!range.isEmpty() || ((range = session.getWordRange(range.start.row, range.start.column)).cursor = -1 == dir ? range.start : range.end, this.multiSelect.addRange(range), !stopAtFirst)) { + var session1, needle, dir1, needle2 = session.getTextRange(range), newRange = (session1 = session, needle = needle2, dir1 = dir, search.$options.wrap = !0, search.$options.needle = needle, search.$options.backwards = -1 == dir1, search.find(session1)); + newRange && (newRange.cursor = -1 == dir ? newRange.start : newRange.end, this.session.unfold(newRange), this.multiSelect.addRange(newRange), this.renderer.scrollCursorIntoView(null, 0.5)), skip && this.multiSelect.substractPoint(range.cursor); + } + }, this.alignCursors = function() { + var session = this.session, sel = session.multiSelect, ranges = sel.ranges, row = -1, sameRowRanges = ranges.filter(function(r) { + if (r.cursor.row == row) return !0; + row = r.cursor.row; + }); + if (ranges.length && sameRowRanges.length != ranges.length - 1) { + sameRowRanges.forEach(function(r) { + sel.substractPoint(r.cursor); + }); + var maxCol = 0, minSpace = 1 / 0, spaceOffsets = ranges.map(function(r) { + var p = r.cursor, spaceOffset = session.getLine(p.row).substr(p.column).search(/\S/g); + return -1 == spaceOffset && (spaceOffset = 0), p.column > maxCol && (maxCol = p.column), spaceOffset < minSpace && (minSpace = spaceOffset), spaceOffset; + }); + ranges.forEach(function(r, i) { + var p = r.cursor, l = maxCol - p.column, d = spaceOffsets[i] - minSpace; + l > d ? session.insert(p, lang.stringRepeat(" ", l - d)) : session.remove(new Range(p.row, p.column, p.row, p.column - l + d)), r.start.column = r.end.column = maxCol, r.start.row = r.end.row = p.row, r.cursor = r.end; + }), sel.fromOrientedRange(ranges[0]), this.renderer.updateCursor(), this.renderer.updateBackMarkers(); + } else { + var range = this.selection.getRange(), fr = range.start.row, lr = range.end.row, guessRange = fr == lr; + if (guessRange) { + var line, max = this.session.getLength(); + do line = this.session.getLine(lr); + while (/[=:]/.test(line) && ++lr < max) + do line = this.session.getLine(fr); + while (/[=:]/.test(line) && --fr > 0) + fr < 0 && (fr = 0), lr >= max && (lr = max - 1); + } + var lines = this.session.removeFullLines(fr, lr); + lines = this.$reAlignText(lines, guessRange), this.session.insert({ + row: fr, + column: 0 + }, lines.join("\n") + "\n"), guessRange || (range.start.column = 0, range.end.column = lines[lines.length - 1].length), this.selection.setRange(range); + } + }, this.$reAlignText = function(lines, forceLeft) { + var startW, textW, endW, isLeftAligned = !0, isRightAligned = !0; + return lines.map(function(line) { + var m = line.match(/(\s*)(.*?)(\s*)([=:].*)/); + return m ? null == startW ? (startW = m[1].length, textW = m[2].length, endW = m[3].length, m) : (startW + textW + endW != m[1].length + m[2].length + m[3].length && (isRightAligned = !1), startW != m[1].length && (isLeftAligned = !1), startW > m[1].length && (startW = m[1].length), textW < m[2].length && (textW = m[2].length), endW > m[3].length && (endW = m[3].length), m) : [ + line + ]; + }).map(forceLeft ? alignLeft : isLeftAligned ? isRightAligned ? function(m) { + return m[2] ? spaces(startW + textW - m[2].length) + m[2] + spaces(endW) + m[4].replace(/^([=:])\s+/, "$1 ") : m[0]; + } : alignLeft : function(m) { + return m[2] ? spaces(startW) + m[2] + spaces(endW) + m[4].replace(/^([=:])\s+/, "$1 ") : m[0]; + }); + function spaces(n) { + return lang.stringRepeat(" ", n); + } + function alignLeft(m) { + return m[2] ? spaces(startW) + m[2] + spaces(textW - m[2].length + endW) + m[4].replace(/^([=:])\s+/, "$1 ") : m[0]; + } + }; + }).call(Editor.prototype), exports.onSessionChange = function(e) { + var session = e.session; + session && !session.multiSelect && (session.$selectionMarkers = [], session.selection.$initRangeList(), session.multiSelect = session.selection), this.multiSelect = session && session.multiSelect; + var oldSession = e.oldSession; + oldSession && (oldSession.multiSelect.off("addRange", this.$onAddRange), oldSession.multiSelect.off("removeRange", this.$onRemoveRange), oldSession.multiSelect.off("multiSelect", this.$onMultiSelect), oldSession.multiSelect.off("singleSelect", this.$onSingleSelect), oldSession.multiSelect.lead.off("change", this.$checkMultiselectChange), oldSession.multiSelect.anchor.off("change", this.$checkMultiselectChange)), session && (session.multiSelect.on("addRange", this.$onAddRange), session.multiSelect.on("removeRange", this.$onRemoveRange), session.multiSelect.on("multiSelect", this.$onMultiSelect), session.multiSelect.on("singleSelect", this.$onSingleSelect), session.multiSelect.lead.on("change", this.$checkMultiselectChange), session.multiSelect.anchor.on("change", this.$checkMultiselectChange)), session && this.inMultiSelectMode != session.selection.inMultiSelectMode && (session.selection.inMultiSelectMode ? this.$onMultiSelect() : this.$onSingleSelect()); + }, exports.MultiSelect = MultiSelect, require("./config").defineOptions(Editor.prototype, "editor", { + enableMultiselect: { + set: function(val) { + MultiSelect(this), val ? (this.on("changeSession", this.$multiselectOnSessionChange), this.on("mousedown", onMouseDown)) : (this.off("changeSession", this.$multiselectOnSessionChange), this.off("mousedown", onMouseDown)); + }, + value: !0 + }, + enableBlockSelect: { + set: function(val) { + this.$blockSelectEnabled = val; + }, + value: !0 + } + }); + }), ace.define("ace/mode/folding/fold_mode", [ + "require", + "exports", + "module", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var Range = require("../../range").Range, FoldMode = exports.FoldMode = function() {}; + (function() { + this.foldingStartMarker = null, this.foldingStopMarker = null, this.getFoldWidget = function(session, foldStyle, row) { + var line = session.getLine(row); + return this.foldingStartMarker.test(line) ? "start" : "markbeginend" == foldStyle && this.foldingStopMarker && this.foldingStopMarker.test(line) ? "end" : ""; + }, this.getFoldWidgetRange = function(session, foldStyle, row) { + return null; + }, this.indentationBlock = function(session, row, column) { + var re = /\S/, line = session.getLine(row), startLevel = line.search(re); + if (-1 != startLevel) { + for(var startColumn = column || line.length, maxRow = session.getLength(), startRow = row, endRow = row; ++row < maxRow;){ + var level = session.getLine(row).search(re); + if (-1 != level) { + if (level <= startLevel) { + var token = session.getTokenAt(row, 0); + if (!token || "string" !== token.type) break; + } + endRow = row; + } + } + if (endRow > startRow) { + var endColumn = session.getLine(endRow).length; + return new Range(startRow, startColumn, endRow, endColumn); + } + } + }, this.openingBracketBlock = function(session, bracket, row, column, typeRe) { + var start = { + row: row, + column: column + 1 + }, end = session.$findClosingBracket(bracket, start, typeRe); + if (end) { + var fw = session.foldWidgets[end.row]; + return null == fw && (fw = session.getFoldWidget(end.row)), "start" == fw && end.row > start.row && (end.row--, end.column = session.getLine(end.row).length), Range.fromPoints(start, end); + } + }, this.closingBracketBlock = function(session, bracket, row, column, typeRe) { + var end = { + row: row, + column: column + }, start = session.$findOpeningBracket(bracket, end); + if (start) return start.column++, end.column--, Range.fromPoints(start, end); + }; + }).call(FoldMode.prototype); + }), ace.define("ace/theme/textmate", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + exports.isDark = !1, exports.cssClass = "ace-tm", exports.cssText = ".ace-tm .ace_gutter {\ +background: #f0f0f0;\ +color: #333;\ +}\ +.ace-tm .ace_print-margin {\ +width: 1px;\ +background: #e8e8e8;\ +}\ +.ace-tm .ace_fold {\ +background-color: #6B72E6;\ +}\ +.ace-tm {\ +background-color: #FFFFFF;\ +color: black;\ +}\ +.ace-tm .ace_cursor {\ +color: black;\ +}\ +.ace-tm .ace_invisible {\ +color: rgb(191, 191, 191);\ +}\ +.ace-tm .ace_storage,\ +.ace-tm .ace_keyword {\ +color: blue;\ +}\ +.ace-tm .ace_constant {\ +color: rgb(197, 6, 11);\ +}\ +.ace-tm .ace_constant.ace_buildin {\ +color: rgb(88, 72, 246);\ +}\ +.ace-tm .ace_constant.ace_language {\ +color: rgb(88, 92, 246);\ +}\ +.ace-tm .ace_constant.ace_library {\ +color: rgb(6, 150, 14);\ +}\ +.ace-tm .ace_invalid {\ +background-color: rgba(255, 0, 0, 0.1);\ +color: red;\ +}\ +.ace-tm .ace_support.ace_function {\ +color: rgb(60, 76, 114);\ +}\ +.ace-tm .ace_support.ace_constant {\ +color: rgb(6, 150, 14);\ +}\ +.ace-tm .ace_support.ace_type,\ +.ace-tm .ace_support.ace_class {\ +color: rgb(109, 121, 222);\ +}\ +.ace-tm .ace_keyword.ace_operator {\ +color: rgb(104, 118, 135);\ +}\ +.ace-tm .ace_string {\ +color: rgb(3, 106, 7);\ +}\ +.ace-tm .ace_comment {\ +color: rgb(76, 136, 107);\ +}\ +.ace-tm .ace_comment.ace_doc {\ +color: rgb(0, 102, 255);\ +}\ +.ace-tm .ace_comment.ace_doc.ace_tag {\ +color: rgb(128, 159, 191);\ +}\ +.ace-tm .ace_constant.ace_numeric {\ +color: rgb(0, 0, 205);\ +}\ +.ace-tm .ace_variable {\ +color: rgb(49, 132, 149);\ +}\ +.ace-tm .ace_xml-pe {\ +color: rgb(104, 104, 91);\ +}\ +.ace-tm .ace_entity.ace_name.ace_function {\ +color: #0000A2;\ +}\ +.ace-tm .ace_heading {\ +color: rgb(12, 7, 255);\ +}\ +.ace-tm .ace_list {\ +color:rgb(185, 6, 144);\ +}\ +.ace-tm .ace_meta.ace_tag {\ +color:rgb(0, 22, 142);\ +}\ +.ace-tm .ace_string.ace_regex {\ +color: rgb(255, 0, 0)\ +}\ +.ace-tm .ace_marker-layer .ace_selection {\ +background: rgb(181, 213, 255);\ +}\ +.ace-tm.ace_multiselect .ace_selection.ace_start {\ +box-shadow: 0 0 3px 0px white;\ +}\ +.ace-tm .ace_marker-layer .ace_step {\ +background: rgb(252, 255, 0);\ +}\ +.ace-tm .ace_marker-layer .ace_stack {\ +background: rgb(164, 229, 101);\ +}\ +.ace-tm .ace_marker-layer .ace_bracket {\ +margin: -1px 0 0 -1px;\ +border: 1px solid rgb(192, 192, 192);\ +}\ +.ace-tm .ace_marker-layer .ace_active-line {\ +background: rgba(0, 0, 0, 0.07);\ +}\ +.ace-tm .ace_gutter-active-line {\ +background-color : #dcdcdc;\ +}\ +.ace-tm .ace_marker-layer .ace_selected-word {\ +background: rgb(250, 250, 255);\ +border: 1px solid rgb(200, 200, 250);\ +}\ +.ace-tm .ace_indent-guide {\ +background: url(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAACCAYAAACZgbYnAAAAE0lEQVQImWP4////f4bLly//BwAmVgd1/w11/gAAAABJRU5ErkJggg==\") right repeat-y;\ +}\ +", exports.$id = "ace/theme/textmate", require("../lib/dom").importCssString(exports.cssText, exports.cssClass, !1); + }), ace.define("ace/line_widgets", [ + "require", + "exports", + "module", + "ace/lib/dom" + ], function(require, exports, module) { + "use strict"; + var dom = require("./lib/dom"); + function LineWidgets(session) { + this.session = session, this.session.widgetManager = this, this.session.getRowLength = this.getRowLength, this.session.$getWidgetScreenLength = this.$getWidgetScreenLength, this.updateOnChange = this.updateOnChange.bind(this), this.renderWidgets = this.renderWidgets.bind(this), this.measureWidgets = this.measureWidgets.bind(this), this.session._changedWidgets = [], this.$onChangeEditor = this.$onChangeEditor.bind(this), this.session.on("change", this.updateOnChange), this.session.on("changeFold", this.updateOnFold), this.session.on("changeEditor", this.$onChangeEditor); + } + (function() { + this.getRowLength = function(row) { + var h; + return (h = this.lineWidgets ? this.lineWidgets[row] && this.lineWidgets[row].rowCount || 0 : 0, this.$useWrapMode && this.$wrapData[row]) ? this.$wrapData[row].length + 1 + h : 1 + h; + }, this.$getWidgetScreenLength = function() { + var screenRows = 0; + return this.lineWidgets.forEach(function(w) { + w && w.rowCount && !w.hidden && (screenRows += w.rowCount); + }), screenRows; + }, this.$onChangeEditor = function(e) { + this.attach(e.editor); + }, this.attach = function(editor) { + editor && editor.widgetManager && editor.widgetManager != this && editor.widgetManager.detach(), this.editor != editor && (this.detach(), this.editor = editor, editor && (editor.widgetManager = this, editor.renderer.on("beforeRender", this.measureWidgets), editor.renderer.on("afterRender", this.renderWidgets))); + }, this.detach = function(e) { + var editor = this.editor; + if (editor) { + this.editor = null, editor.widgetManager = null, editor.renderer.off("beforeRender", this.measureWidgets), editor.renderer.off("afterRender", this.renderWidgets); + var lineWidgets = this.session.lineWidgets; + lineWidgets && lineWidgets.forEach(function(w) { + w && w.el && w.el.parentNode && (w._inDocument = !1, w.el.parentNode.removeChild(w.el)); + }); + } + }, this.updateOnFold = function(e, session) { + var lineWidgets = session.lineWidgets; + if (lineWidgets && e.action) { + for(var fold = e.data, start = fold.start.row, end = fold.end.row, hide = "add" == e.action, i = start + 1; i < end; i++)lineWidgets[i] && (lineWidgets[i].hidden = hide); + lineWidgets[end] && (hide ? lineWidgets[start] ? lineWidgets[end].hidden = hide : lineWidgets[start] = lineWidgets[end] : (lineWidgets[start] == lineWidgets[end] && (lineWidgets[start] = void 0), lineWidgets[end].hidden = hide)); + } + }, this.updateOnChange = function(delta) { + var lineWidgets = this.session.lineWidgets; + if (lineWidgets) { + var startRow = delta.start.row, len = delta.end.row - startRow; + if (0 === len) ; + else if ("remove" == delta.action) { + var removed = lineWidgets.splice(startRow + 1, len); + !lineWidgets[startRow] && removed[removed.length - 1] && (lineWidgets[startRow] = removed.pop()), removed.forEach(function(w) { + w && this.removeLineWidget(w); + }, this), this.$updateRows(); + } else { + var args = new Array(len); + lineWidgets[startRow] && null != lineWidgets[startRow].column && delta.start.column > lineWidgets[startRow].column && startRow++, args.unshift(startRow, 0), lineWidgets.splice.apply(lineWidgets, args), this.$updateRows(); + } + } + }, this.$updateRows = function() { + var lineWidgets = this.session.lineWidgets; + if (lineWidgets) { + var noWidgets = !0; + lineWidgets.forEach(function(w, i) { + if (w) for(noWidgets = !1, w.row = i; w.$oldWidget;)w.$oldWidget.row = i, w = w.$oldWidget; + }), noWidgets && (this.session.lineWidgets = null); + } + }, this.$registerLineWidget = function(w) { + this.session.lineWidgets || (this.session.lineWidgets = new Array(this.session.getLength())); + var old = this.session.lineWidgets[w.row]; + return old && (w.$oldWidget = old, old.el && old.el.parentNode && (old.el.parentNode.removeChild(old.el), old._inDocument = !1)), this.session.lineWidgets[w.row] = w, w; + }, this.addLineWidget = function(w) { + if (this.$registerLineWidget(w), w.session = this.session, !this.editor) return w; + var renderer = this.editor.renderer; + w.html && !w.el && (w.el = dom.createElement("div"), w.el.innerHTML = w.html), w.el && (dom.addCssClass(w.el, "ace_lineWidgetContainer"), w.el.style.position = "absolute", w.el.style.zIndex = 5, renderer.container.appendChild(w.el), w._inDocument = !0, w.coverGutter || (w.el.style.zIndex = 3), null == w.pixelHeight && (w.pixelHeight = w.el.offsetHeight)), null == w.rowCount && (w.rowCount = w.pixelHeight / renderer.layerConfig.lineHeight); + var fold = this.session.getFoldAt(w.row, 0); + if (w.$fold = fold, fold) { + var lineWidgets = this.session.lineWidgets; + w.row != fold.end.row || lineWidgets[fold.start.row] ? w.hidden = !0 : lineWidgets[fold.start.row] = w; + } + return this.session._emit("changeFold", { + data: { + start: { + row: w.row + } + } + }), this.$updateRows(), this.renderWidgets(null, renderer), this.onWidgetChanged(w), w; + }, this.removeLineWidget = function(w) { + if (w._inDocument = !1, w.session = null, w.el && w.el.parentNode && w.el.parentNode.removeChild(w.el), w.editor && w.editor.destroy) try { + w.editor.destroy(); + } catch (e) {} + if (this.session.lineWidgets) { + var w1 = this.session.lineWidgets[w.row]; + if (w1 == w) this.session.lineWidgets[w.row] = w.$oldWidget, w.$oldWidget && this.onWidgetChanged(w.$oldWidget); + else for(; w1;){ + if (w1.$oldWidget == w) { + w1.$oldWidget = w.$oldWidget; + break; + } + w1 = w1.$oldWidget; + } + } + this.session._emit("changeFold", { + data: { + start: { + row: w.row + } + } + }), this.$updateRows(); + }, this.getWidgetsAtRow = function(row) { + for(var lineWidgets = this.session.lineWidgets, w = lineWidgets && lineWidgets[row], list = []; w;)list.push(w), w = w.$oldWidget; + return list; + }, this.onWidgetChanged = function(w) { + this.session._changedWidgets.push(w), this.editor && this.editor.renderer.updateFull(); + }, this.measureWidgets = function(e, renderer) { + var changedWidgets = this.session._changedWidgets, config = renderer.layerConfig; + if (changedWidgets && changedWidgets.length) { + for(var min = 1 / 0, i = 0; i < changedWidgets.length; i++){ + var w = changedWidgets[i]; + if (w && w.el && w.session == this.session) { + if (!w._inDocument) { + if (this.session.lineWidgets[w.row] != w) continue; + w._inDocument = !0, renderer.container.appendChild(w.el); + } + w.h = w.el.offsetHeight, w.fixedWidth || (w.w = w.el.offsetWidth, w.screenWidth = Math.ceil(w.w / config.characterWidth)); + var rowCount = w.h / config.lineHeight; + w.coverLine && (rowCount -= this.session.getRowLineCount(w.row)) < 0 && (rowCount = 0), w.rowCount != rowCount && (w.rowCount = rowCount, w.row < min && (min = w.row)); + } + } + min != 1 / 0 && (this.session._emit("changeFold", { + data: { + start: { + row: min + } + } + }), this.session.lineWidgetWidth = null), this.session._changedWidgets = []; + } + }, this.renderWidgets = function(e, renderer) { + var config = renderer.layerConfig, lineWidgets = this.session.lineWidgets; + if (lineWidgets) { + for(var first = Math.min(this.firstRow, config.firstRow), last = Math.max(this.lastRow, config.lastRow, lineWidgets.length); first > 0 && !lineWidgets[first];)first--; + this.firstRow = config.firstRow, this.lastRow = config.lastRow, renderer.$cursorLayer.config = config; + for(var i = first; i <= last; i++){ + var w = lineWidgets[i]; + if (w && w.el) { + if (w.hidden) { + w.el.style.top = -100 - (w.pixelHeight || 0) + "px"; + continue; + } + w._inDocument || (w._inDocument = !0, renderer.container.appendChild(w.el)); + var top = renderer.$cursorLayer.getPixelPosition({ + row: i, + column: 0 + }, !0).top; + w.coverLine || (top += config.lineHeight * this.session.getRowLineCount(w.row)), w.el.style.top = top - config.offset + "px"; + var left = w.coverGutter ? 0 : renderer.gutterWidth; + w.fixedWidth || (left -= renderer.scrollLeft), w.el.style.left = left + "px", w.fullWidth && w.screenWidth && (w.el.style.minWidth = config.width + 2 * config.padding + "px"), w.fixedWidth ? w.el.style.right = renderer.scrollBar.getWidth() + "px" : w.el.style.right = ""; + } + } + } + }; + }).call(LineWidgets.prototype), exports.LineWidgets = LineWidgets; + }), ace.define("ace/ext/error_marker", [ + "require", + "exports", + "module", + "ace/line_widgets", + "ace/lib/dom", + "ace/range" + ], function(require, exports, module) { + "use strict"; + var LineWidgets = require("../line_widgets").LineWidgets, dom = require("../lib/dom"), Range = require("../range").Range; + exports.showErrorMarker = function(editor, dir2) { + var gutterAnno, session2 = editor.session; + session2.widgetManager || (session2.widgetManager = new LineWidgets(session2), session2.widgetManager.attach(editor)); + var pos = editor.getCursorPosition(), row3 = pos.row, oldWidget = session2.widgetManager.getWidgetsAtRow(row3).filter(function(w) { + return "errorMarker" == w.type; + })[0]; + oldWidget ? oldWidget.destroy() : row3 -= dir2; + var annotations1 = function(session, row, dir) { + var annotations = session.getAnnotations().sort(Range.comparePoints); + if (annotations.length) { + var i = function(array, needle, comparator) { + for(var first = 0, last = array.length - 1; first <= last;){ + var mid = first + last >> 1, c = comparator(needle, array[mid]); + if (c > 0) first = mid + 1; + else { + if (!(c < 0)) return mid; + last = mid - 1; + } + } + return -(first + 1); + }(annotations, { + row: row, + column: -1 + }, Range.comparePoints); + i < 0 && (i = -i - 1), i >= annotations.length ? i = dir > 0 ? 0 : annotations.length - 1 : 0 === i && dir < 0 && (i = annotations.length - 1); + var annotation = annotations[i]; + if (annotation && dir) { + if (annotation.row === row) { + do annotation = annotations[i += dir]; + while (annotation && annotation.row === row) + if (!annotation) return annotations.slice(); + } + var matched = []; + row = annotation.row; + do matched[dir < 0 ? "unshift" : "push"](annotation), annotation = annotations[i += dir]; + while (annotation && annotation.row == row) + return matched.length && matched; + } + } + }(session2, row3, dir2); + if (annotations1) { + var annotation1 = annotations1[0]; + pos.column = (annotation1.pos && "number" != typeof annotation1.column ? annotation1.pos.sc : annotation1.column) || 0, pos.row = annotation1.row, gutterAnno = editor.renderer.$gutterLayer.$annotations[pos.row]; + } else { + if (oldWidget) return; + gutterAnno = { + text: [ + "Looks good!" + ], + className: "ace_ok" + }; + } + editor.session.unfold(pos.row), editor.selection.moveToPosition(pos); + var w2 = { + row: pos.row, + fixedWidth: !0, + coverGutter: !0, + el: dom.createElement("div"), + type: "errorMarker" + }, el = w2.el.appendChild(dom.createElement("div")), arrow = w2.el.appendChild(dom.createElement("div")); + arrow.className = "error_widget_arrow " + gutterAnno.className; + var left = editor.renderer.$cursorLayer.getPixelPosition(pos).left; + arrow.style.left = left + editor.renderer.gutterWidth - 5 + "px", w2.el.className = "error_widget_wrapper", el.className = "error_widget " + gutterAnno.className, el.innerHTML = gutterAnno.text.join("
"), el.appendChild(dom.createElement("div")); + var kb = function(_, hashId, keyString) { + if (0 === hashId && ("esc" === keyString || "return" === keyString)) return w2.destroy(), { + command: "null" + }; + }; + w2.destroy = function() { + editor.$mouseHandler.isMousePressed || (editor.keyBinding.removeKeyboardHandler(kb), session2.widgetManager.removeLineWidget(w2), editor.off("changeSelection", w2.destroy), editor.off("changeSession", w2.destroy), editor.off("mouseup", w2.destroy), editor.off("change", w2.destroy)); + }, editor.keyBinding.addKeyboardHandler(kb), editor.on("changeSelection", w2.destroy), editor.on("changeSession", w2.destroy), editor.on("mouseup", w2.destroy), editor.on("change", w2.destroy), editor.session.widgetManager.addLineWidget(w2), w2.el.onmousedown = editor.focus.bind(editor), editor.renderer.scrollCursorIntoView(null, 0.5, { + bottom: w2.el.offsetHeight + }); + }, dom.importCssString("\ + .error_widget_wrapper {\ + background: inherit;\ + color: inherit;\ + border:none\ + }\ + .error_widget {\ + border-top: solid 2px;\ + border-bottom: solid 2px;\ + margin: 5px 0;\ + padding: 10px 40px;\ + white-space: pre-wrap;\ + }\ + .error_widget.ace_error, .error_widget_arrow.ace_error{\ + border-color: #ff5a5a\ + }\ + .error_widget.ace_warning, .error_widget_arrow.ace_warning{\ + border-color: #F1D817\ + }\ + .error_widget.ace_info, .error_widget_arrow.ace_info{\ + border-color: #5a5a5a\ + }\ + .error_widget.ace_ok, .error_widget_arrow.ace_ok{\ + border-color: #5aaa5a\ + }\ + .error_widget_arrow {\ + position: absolute;\ + border: solid 5px;\ + border-top-color: transparent!important;\ + border-right-color: transparent!important;\ + border-left-color: transparent!important;\ + top: -5px;\ + }\ +", "error_marker.css", !1); + }), ace.define("ace/ace", [ + "require", + "exports", + "module", + "ace/lib/fixoldbrowsers", + "ace/lib/dom", + "ace/lib/event", + "ace/range", + "ace/editor", + "ace/edit_session", + "ace/undomanager", + "ace/virtual_renderer", + "ace/worker/worker_client", + "ace/keyboard/hash_handler", + "ace/placeholder", + "ace/multi_select", + "ace/mode/folding/fold_mode", + "ace/theme/textmate", + "ace/ext/error_marker", + "ace/config" + ], function(require, exports, module) { + "use strict"; + require("./lib/fixoldbrowsers"); + var dom = require("./lib/dom"), event = require("./lib/event"), Range = require("./range").Range, Editor = require("./editor").Editor, EditSession = require("./edit_session").EditSession, UndoManager = require("./undomanager").UndoManager, Renderer = require("./virtual_renderer").VirtualRenderer; + require("./worker/worker_client"), require("./keyboard/hash_handler"), require("./placeholder"), require("./multi_select"), require("./mode/folding/fold_mode"), require("./theme/textmate"), require("./ext/error_marker"), exports.config = require("./config"), exports.require = require, exports.define = __webpack_require__.amdD, exports.edit = function(el, options) { + if ("string" == typeof el) { + var _id = el; + if (!(el = document.getElementById(_id))) throw new Error("ace.edit can't find div #" + _id); + } + if (el && el.env && el.env.editor instanceof Editor) return el.env.editor; + var value = ""; + if (el && /input|textarea/i.test(el.tagName)) { + var oldNode = el; + value = oldNode.value, el = dom.createElement("pre"), oldNode.parentNode.replaceChild(el, oldNode); + } else el && (value = el.textContent, el.innerHTML = ""); + var doc = exports.createEditSession(value), editor = new Editor(new Renderer(el), doc, options), env = { + document: doc, + editor: editor, + onResize: editor.resize.bind(editor, null) + }; + return oldNode && (env.textarea = oldNode), event.addListener(window, "resize", env.onResize), editor.on("destroy", function() { + event.removeListener(window, "resize", env.onResize), env.editor.container.env = null; + }), editor.container.env = editor.env = env, editor; + }, exports.createEditSession = function(text, mode) { + var doc = new EditSession(text, mode); + return doc.setUndoManager(new UndoManager()), doc; + }, exports.Range = Range, exports.Editor = Editor, exports.EditSession = EditSession, exports.UndoManager = UndoManager, exports.VirtualRenderer = Renderer, exports.version = exports.config.version; + }), ace.require([ + "ace/ace" + ], function(a) { + for(var key in a && (a.config.init(!0), a.define = ace.define), window.ace || (window.ace = a), a)a.hasOwnProperty(key) && (window.ace[key] = a[key]); + window.ace.default = window.ace, module1 && (module1.exports = window.ace); + }); + } + } +]); diff --git a/crates/swc_ecma_minifier/tests/projects/output/mootools-1.4.5.js b/crates/swc_ecma_minifier/tests/projects/output/mootools-1.4.5.js index 669108a8014b..317fe1445339 100644 --- a/crates/swc_ecma_minifier/tests/projects/output/mootools-1.4.5.js +++ b/crates/swc_ecma_minifier/tests/projects/output/mootools-1.4.5.js @@ -1844,22 +1844,26 @@ Elements.prototype = { return document.id(Slick.find(this, expression)); } }); - var set, translations, types, search, find, match, pseudos, addSlickPseudos, contains = { + var set, translations, contains = { contains: function(element) { return Slick.contains(this, element); } }; document.contains || Document.implement(contains), document.createElement('div').contains || Element.implement(contains), Element.implement('hasChild', function(element) { return this !== element && this.contains(element); - }), search = Slick.search, find = Slick.find, match = Slick.match, this.Selectors = {}, pseudos = this.Selectors.Pseudo = new Hash(), addSlickPseudos = function() { - for(var name in pseudos)pseudos.hasOwnProperty(name) && (Slick.definePseudo(name, pseudos[name]), delete pseudos[name]); - }, Slick.search = function(context, expression, append) { - return addSlickPseudos(), search.call(this, context, expression, append); - }, Slick.find = function(context, expression) { - return addSlickPseudos(), find.call(this, context, expression); - }, Slick.match = function(node, selector) { - return addSlickPseudos(), match.call(this, node, selector); - }; + }), function(search, find, match) { + this.Selectors = {}; + var pseudos = this.Selectors.Pseudo = new Hash(), addSlickPseudos = function() { + for(var name in pseudos)pseudos.hasOwnProperty(name) && (Slick.definePseudo(name, pseudos[name]), delete pseudos[name]); + }; + Slick.search = function(context, expression, append) { + return addSlickPseudos(), search.call(this, context, expression, append); + }, Slick.find = function(context, expression) { + return addSlickPseudos(), find.call(this, context, expression); + }, Slick.match = function(node, selector) { + return addSlickPseudos(), match.call(this, node, selector); + }; + }(Slick.search, Slick.find, Slick.match); var injectCombinator = function(expression, combinator) { if (!expression) return combinator; for(var expressions = (expression = Object.clone(Slick.parse(expression))).expressions, i = expressions.length; i--;)expressions[i][0].combinator = combinator; @@ -2019,7 +2023,7 @@ Elements.prototype = { 'button' != el1.type && (propertySetters.type = function(node, value) { node.setAttribute('type', value); }), el1 = null; - var div, input = document.createElement('input'); + var types, div, input = document.createElement('input'); input.value = 't', input.type = 'submit', 't' != input.value && (propertySetters.type = function(node, type) { var value = node.value; node.type = type, node.value = value;